Mensajes

lo que creas con new, lo borras con delete y lo que creas con new[] lo tienes que borrar con delete[]:

Código (cpp) [Seleccionar] Expandir


int* ptr = new int;
delete ptr;

ptr = new int[10];
delete[] ptr;

[ivancea96]

Lo que te ha comentado ivancea96 es correcto.

Sin embargo creo que es conveniente hacer una matización:

* Si accedes a una estructura por valor, tienes que usar el operador de miembro '.' para acceder a sus elementos.
* Si accedes a una estructura a través de un puntero, entonces el operador que te permite acceder a los miembros de la estructura es el operador de puntero '->'.

Un ejemplo:

Código (cpp) [Seleccionar] Expandir


struct Estructura
{
  int dato;
};

int main( )
{
  Estructura var1;
  var1.dato = 5; // a var1 accedemos por valor.

  Estructura* ptr = &var1;
  // ptr es un puntero, para acceder al miembro de la estructura tenemos que usar un el operador de puntero
  std::cout << ptr->dato << std::endl;

  Estructura* lista = new Estructura[ 2 ];
 
  // "lista" es un puntero, pero "lista[x]" no, aquí estamos accediendo a la estructura por valor, necesitamos
  // el operador de miembro
  lista[ 0 ].dato = 44;

  Estructura** lista2 = new Estructura*[ 2 ];
  lista2[ 0 ] = new Estructura( );
  lista2[ 1 ] = new Estructura( );

  // "lista2" es un puntero doble, por tanto, "lista2[x]" es un puntero a una estructura. Para acceder a los
  // miembros de dicha estructura necesitamos el operador de puntero.
  lista2[ 0 ]->dato = 85;

  // Faltan los correspondientes "delete" para liberar la memoria reservada, pero no es lo que se
  // está preguntando en este hilo.
}

Esta es la estructura del nodo, según lo que entiendo yo , en tNodo tengo el dato a guardar, y la dirección del siguiente nodo .  Y luego defino un alias tipo puntero (?) de tipo tNodo .

Código (cpp) [Seleccionar] Expandir

typedef struct Nodo { /* ... */  } tNodo;

Ahí estás definiendo una estructura, cuyo nombre oficial es "struct Nodo", a dicha estructura le asignas un alias, "tNodo". De esta forma "struct Nodo" y "tNodo" son equivalentes. Se podría hacer también en dos pasos (por si te resulta más claro):

Código (cpp) [Seleccionar] Expandir

struct Nodo { /* ... */  };
typedef struct Nodo tNodo;

En la primera línea se define la estructura "Nodo" y en la segunda creamos el alias.

Código (cpp) [Seleccionar] Expandir

typedef tNodo *TipoLista;

Ahí estás creando un alias nuevo, "TipoLista", este alias es equivalente a "tNodo*", es decir, es un puntero a una estructura de tipo "tNodo"

Código (cpp) [Seleccionar] Expandir

nodo = (TipoLista) malloc(sizeof(TipoLista));

Si TipoLista es un alias de "struct Nodo*" entonces sizeof(TipoLista) devuelve el tamaño de un puntero, no de una estructura. La consecuencia es que no estás reservando la memoria suficiente para almacenar una estructura de tipo "Nodo". Hay que ser cuidadoso a la hora de usar alias, si en algún momento no tienes claro el uso del alias vas a meter la pata fijo.

Código (cpp) [Seleccionar] Expandir

nodo = (TipoLista) malloc(sizeof(tNodo));

Ahora, malloc reservará una cantidad de memoria suficiente para almacenar un "struct Nodo" y te devolverá el puntero correspondiente, que sí podrás usar sin problemas porque no vas a pisar memoria que no te pertenece.

no tengo que poner * primero, ejemplo *nodo->dato=carga_uno() ??

Hay dos formas de acceder a los elementos de una estructura a la que accedes a través de un puntero:

Código (cpp) [Seleccionar] Expandir


TipoLista nodo = FuncionQueMeDevuelveUnNodoValido( );

TipoLista siguiente1 = nodo->sig;
TipoLista siguiente2 = (*nodo).sig;

"siguiente1" y "siguiente2" van a apuntar ambas al mismo sitio. En el primer caso hemos hecho uso del operador de referencia "->". Este operador indica que nuestra variable es realmente un puntero y que accedemos a sus elementos por referencia, no por valor. En el segundo caso estamos haciendo uso del operador "*" que nos permite acceder por valor a los elementos del puntero, como ya no estamos trabajando con punteros debemos usar el operador "." para acceder a sus elementos.

No se si con estas explicaciones te aclaro un poco el asunto. Si tienes más dudas no tengas inconveniente en preguntar.

Un saludo.

Código (cpp) [Seleccionar] Expandir

       if(encontrado == 1)
       {
           printf("El legajo ya existe\n");
           return;
       }
       else
       {
        fclose(archivo);
           CargarRegistro();
       }


Si encuentra el legajo... ¿dónde es exactamente cuando se cierra el fichero abierto?

Y tienes otras fugas por ahí:

Código (cpp) [Seleccionar] Expandir


                switch(confirmar)
                {
                    case 1:
                        datos.activo[0] = '0';
                        fwrite(&datos, sizeof(registro), 1, archivo);
                        fclose(archivo);
                        return;
                        break;

                    case 2: return; break; // <<<<------ AQUI!!!!
                }

Además, no entiendo este código:

Código (cpp) [Seleccionar] Expandir


void Baja(registro datos)
{
    int legajo = 0;
    int confirmar = 0;
    FILE *archivo;

    printf("Ingrese un numero de legajo (0 para salir): \n");
    scanf("%d", &legajo);

    while(legajo != 0) // <<<< ----- ESTO!!!
    {
    }
}

Si "legajo" no va a cambiar de valor... por qué no pones un simple "if"??

No se, deberías revisar un poco más a fondo tu código.

Si cada vez que entras en, por ejemplo "Altas", haces "fopen", deberías hacer también "fclose". Básicamente porque si no el fichero se queda abierto y te puede dar problemas si intentas abrirlo de nuevo (desde imposibilidad para poder abrirlo hasta almacenar en el fichero información aleatoria)

[mDrinky]

generalizando lo dicho por mDrinky... cada "case" de un "switch" necesita un "break" para que el código salga del "switch", si no pones dicho "break", se ejecuta el código del siguiente "case".

Te lo comento porque he visto que no has puesto un solo "break" en tu código... y tienes varios "switch"

No se me coló, lo puse así para ahorrar una línea por cada pareja de printf y scanf .  

¿No debería ser un punto y coma en vez de solamente una coma? jejeje

Y dale, ¡Ouggg Gran Maestro!, estando tú presente ni me atrevo a esas cosas.  

Gran maestro yo??? jajajaja, me halagas. Tampoco te creas que soy un gurú de las macros... de echo prefiero evitarlas salvo para cosas muy muy muy concretas. Yo personalmente pienso que las macros son uno de los cánceres de C++... la compilación de programas en C++ es lentísima en parte gracias a la existencia de las macros... no ofrecen ningún tipo de tipado... su código no se puede depurar...

[leosansan]

leosansan, se te coló una coma entre el printf y el scanf.

Por un momento pensé que ibas a meter macros jejejeje

Si todavía necesitas hacerlo de la forma " 'A' || 'a' " entonces puedes utilizar un else if para hacerlo.

No has leído las respuestas anteriores, ¿verdad?

Código (cpp) [Seleccionar] Expandir

switch(opcion){
                 
    case 'a':
    case 'A':
          printf("La suma de %g + %g = %g ",num1,num2,num1+num2);             
                 break;
                 
                 
    }

Si utilizas ese codigo tendras muy poca seguridad.Solo bastara con analizar los strings del binario y hacer fuerza bruta al pass.Podrian depurar la aplicacion frenar en el strcmp y devolverle true y listo.

¿Y qué propones para evitar eso? Al final la decisión sobre si un acceso es válido o no la toma un salto condicional en ensamblador... cambiar ese código por su opuesto ( o cambiarlo por un salto incondicional) revienta totalmente el chequeo de usuario y contraseña.