Mensajes

Estás intentando comparar un entero(BNombre) con Nombre que es un arreglo de char, fijate en los tipos de datos de tus campos en la estructura. Si quieres comparar busca las funciones que hay en cstring, strcmp() concretamente, aunque después la puedas sustituir por strncmp().

Además aquí:

Código (cpp) [Seleccionar] Expandir

if(BNombre==Plantilla[i].Nombre)
       {
           cout<<Plantilla[i]
           return 0;
       }

Te falta un punto y coma en el cout.

Saludos.

Hay una manera mucho más "sencilla":

Código (dos) [Seleccionar] Expandir

@echo off
for /f "tokens=2 delims=:" %%_ in ('
^(
echo 2^,2l
echo e
^) ^| edlin /b FILEIN.TXT
') do (echo %%_)

El problema sería el delimitador, pero en fin, si no tienes problemas con el formato de texto, puedes usar esta manera.

Un uso práctico es el de saber si un número es par, o saber si un número es múltiplo de otro.

Código (c) [Seleccionar] Expandir

#include <stdio.h>
int main(void)
{
    int i;
    for(i = 1; i <= 15; i++)
    printf("%d%c", i, i % 3 ? ' ' : '\n');
    return 0;
}


Eso es batch, no bash, es muy muy diferente.

Código [Seleccionar] Expandir

if not %var2%==1/2 goto parte3
Eso es incorrecto.

@Exe U, seve estupendo el dwm(creo que eso estás usando), yo quiero tener algo así, pero tengo algunas dudas sobre el manejo del dwm.

Código (python) [Seleccionar] Expandir

from random import randint

PD: Hubiese sido mas sencillo entender el algoritmo si usases los signos de puntuación... ya sabes: comas, puntos... etc
[/quote]

Como toda gente normal.

Pues a mi me parece más poético usar armas de mano... una guadaña o una katana estaría bonito.

Jaja, tienes razón.

Necesitas poner los códigos fuente.

Mira, te pongo un ejemplo, sacado del libro de Deitel, un poco de la clase "complejo" para el manejo de números complejos:
main.cpp:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
using std::cout;
using std::endl;

#include "complejo.h"

int main(void)
{
Complejo x;
Complejo y(4.3, 8.2);
Complejo z(3.3, 1.1);

cout << "x : " << endl;
x.imprime();
cout << "y : " << endl;
y.imprime();
cout << "z : " << endl;
z.imprime();

x = y + z;
cout << " x = y + z : " << endl;
x.imprime();

x = y - z;
cout << "x = y - z : " << endl;
cout << x;

if(x == y)
cout << "Iguales" << endl;
else
cout << "Diferentes" << endl;

Complejo a;
Complejo b;

if(a != b)
{
cout << "Distintos" << endl;
} else {
cout << "Iguales" << endl;
}
return 0;
}


complejo.h

Código (cpp) [Seleccionar] Expandir

// complejo.h
#ifndef COMPLEJO_H
#define COMPLEJO_H
#include <iostream>
using std::ostream;
class Complejo
{
// Interfaz pública:

public:

friend ostream &operator<<(ostream &, const Complejo &);
friend ostream &operator>>(ostream &, const Complejo &);

Complejo(double = 0.0, double = 0.0);
Complejo operator+(const Complejo &) const;
Complejo operator-(const Complejo &) const;

bool operator==(const Complejo&) const;
bool operator!=(const Complejo&) const;

void imprime(void) const;

private:

double real; // Parte real
double imaginaria; // Parte imaginaria.
};

#endif


complejo.cpp:

Código (cpp) [Seleccionar] Expandir

// complejo.cpp
#include <iostream>
using std::cout;

#include "complejo.h"

Complejo::Complejo(double parteReal, double parteImaginaria) : real(parteReal), imaginaria(parteImaginaria)
{
// Parte vacía.
}

// Operador sobrecargado +
Complejo Complejo::operator+(const Complejo &operando2) const
{
return Complejo(real + operando2.real, imaginaria + operando2.imaginaria);
}

// Operador sobrecargado -
Complejo Complejo::operator-(const Complejo &operando2) const
{
return Complejo(real - operando2.real, imaginaria - operando2.imaginaria);
}

void Complejo::imprime(void) const
{
cout << '(' << real << ", " << imaginaria << "i)" << std::endl;
}

ostream &operator<<(ostream& salida, const Complejo& complejo)
{
salida << '(' << complejo.real << ", " << complejo.imaginaria << "i)" << std::endl;
}

// Operadores sobrecargados

bool Complejo::operator==(const Complejo &complejo) const
{
return (*this).real == complejo.real && (*this).imaginaria == complejo.imaginaria;
}

bool Complejo::operator!=(const Complejo &complejo) const
{
return !((*this).real == complejo.real && (*this).imaginaria == complejo.imaginaria);
}


Como ves, es sencillo.

Parece que muchos fantaseamos con matar zombies a diestra y siniestra con un revolver..., ah qué hermoso