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

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

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:

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.
}

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):

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

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

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"

 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.

 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.


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

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.

        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í:

                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:

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)

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 debería ser un punto y coma en vez de solamente una coma? jejeje


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, se te coló una coma entre el printf y el scanf.

Por un momento pensé que ibas a meter macros jejejeje

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

¿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.