Buenos dias:
 
Necesito leer un fichero de texto de vuelos y otro de pasajeros guardarlo en memoria en un array de registros, y posteriormente gestionarlo de momento he conseguido leer uno y gestionarlo, pero no se como almacenarlo en memoria dinamica para que vaya leyendo todos.
 Los problemas principales es que debo leer de un fichero de texto con los campos separados por almohadillas y la otra duda es que debo almacenar todo el texto en memoria sin saber el numero de registros a almacenar.
 Adjunto programa que ya he hecho por si me podeis echar una mano.
 

#include <stdio.h>
 
typedef struct Reg_Vuelos
 {
 char IDVuelo[6];
 char Operadora[7];
 char Aerolinea[5];
 char TipoAvion[4];
 char NumPasajV[4];
 struct Reg_Vuelos *Siguiente;
 }Reg_Vuelos;
 
typedef struct Reg_Pasajeros
 {
 char NumPasajP[4];
 char DNI[9];
 char Nombre[30];
 char Aerolinea[5];
 char TipoAvion[4];
 char Fecha;
 }Reg_Pasajeros; 
 
Reg_Vuelos RVuelos;
 Reg_Pasajeros RPasajeros;
 
 
int main ()
 {
 int Var_Aux = 1; // Variable Auxiliar utilizada para recorrer cada uno de los campos del Registro RegVuelos.
 
// Variables utilizadas dentro del bucles que verifica cuantos clientes vuelan el mismo dia.
 int p;
 int Coincidencias = 0;
 int Repeticiones = 0; 
int k = 0;
 int Avance;
 
char i = 0; // Variable utilizada para rellenar cada uno de los caracteres de los campos del Registro RegVuelos.
 char j = 1; // Variable utilizada para rellenar el campo de los vuelos en que no viajan clientes de nuestra operadora.
 char Cadena_AuxV[40]; // Cadena Auxiliar para recorrer el Archivo Vuelos.txt.
 char Cadena_AuxP[40]; // Cadena Auxiliar para recorrer el Archivo Pasajeros.txt.
 
// Variables utilizadas para Contabilizar los clientes que vuelan en estas Aerolineas.
 int Iberia = 0;
 int Luftansa = 0;
 int American = 0;
 int Ryanair = 0;
 
printf ("Ejecutando proceso. \n\n");
 
printf ("Fichero Informe rellenado. Pulse una tecla \n\n");
 
// Apertura de los tres ficheros de texto a utilizar, Vuelos y Pasajeros en modo lectura y el fichero de salida, Informe en modo escritura
 
FILE *Vuelo = fopen("Vuelos.txt", "r");
 if (Vuelo == NULL)
 {
 perror ("Error al abrir fichero.txt");
 return -1;
 }
 FILE *Pasajero = fopen("Pasajeros.txt", "r");
 if (Pasajero==NULL)
 {
 perror ("Error al abrir fichero.txt");
 return -1;
 }
 FILE *Informe = fopen("Informe.txt", "w");
 if (Informe==NULL)
 {
 perror ("Error al abrir fichero.txt");
 return -1;
 }
 
fprintf (Informe, "Clientes que vuelan mas de dos veces el mismo dia: \n");
 
// Comienza el bucle principal
 
do
 
{
 
Var_Aux = 1;
 i = 0;
 
// Leemos una linea completa del fichero Vuelos.txt y la vamos guardando en la estructura registro
 
do
 {
 Cadena_AuxV[1] = fgetc (Vuelo);
 if (Var_Aux == 1)
 {
 i++;
 RVuelos.IDVuelo[i]= Cadena_AuxV[1];
 if (Cadena_AuxV[1] == '#') 
{
 Var_Aux++;
 i = 0;
 Cadena_AuxV[1] = fgetc (Vuelo);
 }
 } 
if (Var_Aux == 2)
 {
 i++;
 RVuelos.Operadora[i]= Cadena_AuxV[1];
 if (Cadena_AuxV[1] == '#') 
{
 Var_Aux++;
 i = 0;
 Cadena_AuxV[1] = fgetc (Vuelo);
 }
 }
 if (Var_Aux == 3)
 {
 i++;
 RVuelos.Aerolinea[i]= Cadena_AuxV[1];
 if (Cadena_AuxV[1] == '#') 
{
 Var_Aux++;
 i = 0;
 Cadena_AuxV[1] = fgetc (Vuelo);
 }
 }
 if (Var_Aux == 4)
 {
 i++;
 RVuelos.TipoAvion[i]= Cadena_AuxV[1];
 if (Cadena_AuxV[1] == '#') 
{
 Var_Aux++;
 i = 0;
 Cadena_AuxV[1] = fgetc (Vuelo);
 }
 }
 if (Var_Aux == 5)
 {
 i++;
 RVuelos.NumPasajV[i] = Cadena_AuxV[1];
 }
 } 
while (Cadena_AuxV[1] != '\n');
 
// Comprobamos si el cliente es de Nuestra Operadora que Aerolinea ha preferido.
 
if (RVuelos.Operadora[1] == 'N')
 {
 switch (RVuelos.Aerolinea[1])
 {
 case 'I':
 Iberia ++;
 break;
 case 'A':
 American ++;
 break;
 case 'R':
 Ryanair ++;
 break;
 case 'L':
 Luftansa ++;
 break;
 }
 }
 else
 {
 fprintf (Informe, "\nVuelo en el que no viajan clientes de nuestra operadora: ");
 for (j=1; j<7; j++)
 {
 
fprintf (Informe, "%c", RVuelos.IDVuelo[j]);
 }
 fprintf (Informe, "\n");
 }
 
// Este bucle lee el fichero Pasajeros, para comprobar si un cliente vuela varias veces en el mismo dia.
 
do
 {
 k = 1;
 
do
 {
 Avance = 0;
 Cadena_AuxP[1] = fgetc (Pasajero);
 RPasajeros.NumPasajP[k]= Cadena_AuxP[1];
 
 
if (RPasajeros.NumPasajP[k] == RVuelos.NumPasajV[k])
 {
 
Coincidencias ++;
 if (Coincidencias == 4) 
{
 
Repeticiones ++;
 
 
 
Coincidencias = 0;
 if (Repeticiones == 2)
 {
 while (Cadena_AuxP[1] != '#')
 {
 Cadena_AuxP[1] = fgetc (Pasajero);
 }
 for (p = 1; p<10; p++)
 { 
Cadena_AuxP[1] = fgetc (Pasajero);
 RPasajeros.DNI[p]= Cadena_AuxP[1];
 fprintf (Informe,"%c", RPasajeros.DNI[p]);
 
}
 Cadena_AuxP[1] = fgetc (Pasajero);
 fprintf(Informe,"\n");
 Repeticiones = 0;
 
for (p = 1; p<14; p++)
 {
 Cadena_AuxP[1] = fgetc (Pasajero);
 RPasajeros.Nombre[p]= Cadena_AuxP[1];
 fprintf (Informe, "%c", RPasajeros.Nombre[p]);
 }
 fprintf (Informe,"\n");
 Avance = 1;
 for (p = 1; p<13; p++){ 
Cadena_AuxP[1] = fgetc (Pasajero); } 
}
 
}
 
} 
else 
{
 Coincidencias = 0;
 }
 k ++;
 
}
 while (k < 5);
 if (Avance != 1)
 {for (p = 1; p<37; p++){ 
Cadena_AuxP[1] = fgetc (Pasajero);}}
 }
 while ((Cadena_AuxP[1]=fgetc(Pasajero)) != EOF);
 
 
 
 
 
}
 while ((Cadena_AuxV[1]=fgetc(Vuelo)) != EOF); 
 
 
fclose (Vuelo);
 fclose (Pasajero);
 fclose (Informe);
 getch();
 system ("PAUSE");
 return 0;
 } 

Un realloc es una operación muy costosa, yo lo haría de forma amortiguada. Es decir, de 10 en 10:

int añadir_entero(int **vector, int valor, int *nelementos)
{
    static int Actual = 0;
 
    if (Actual == 10)
    {
      int *aux;
 
      if(!(aux = realloc(*vector,((*nelementos) + 10) * sizeof(int))))
          return 0;
 
      *vector = aux;
      (*nelementos) += 10;
      Actual = 0;
    }
 
    (*vector)[*nelementos-(10-Actual)] = valor;
    Actual++;
 
    return 1;
}

El enunciado es el siguiente,

Para mejorar la atención al público de nuestra operadora de viajes de negocios debemos desarrollar una aplicación que transforme y estudie el fichero que, sobre el tráfico aéreo europeo, publica Eurocontrol. El fichero que recibimos de Eurocontrol es un fichero diario de texto con el siguiente formato:
   Nº vuelos
   IDVuelo#Operadora#Aerolínea#TipoAvión#NºPasajeros
   IDVuelo#Operadora#Aerolínea#TipoAvión#NºPasajeros
   ………
Para la gestión de la web de nuestra operadora disponemos de otro fichero en modo texto con el siguiente formato:
   Nº pasajeros
   DNI#Nombre#Aerolínea#TipoAvión#Fecha
   DNI#Nombre#Aerolínea#TipoAvión#Fecha
   ………
La práctica consistirá en implementar una aplicación que recibirá el nombre de los dos ficheros como argumentos y transformará los archivos de datos en una estructura de datos en memoria de la forma siguiente:
 

Una vez creada la estructura de la figura anterior, el programa emitirá un informe que almacenará en un fichero de texto. El informe constará de un listado de los vuelos en los que no viajan clientes de nuestra operadora, el nombre de la aerolínea en la que más vuelan nuestros clientes y el nombre y el DNI de los clientes que aparezcan más de una vez en la estructura, es decir, de aquellos clientes que ese día viajen en avión más de una vez.
El acceso a ficheros y el uso de memoria deberán ser lo más eficientes posibles. El programa deberá estar correctamente estructurado en distintos ficheros con sus correspondientes cabeceras.

Por supuesto, no es lo que pretendo, dime como aprendo yo si el trabajo lo haces tu.
 

Si he puesto las aclaraciones es por que he entendido que me lo decias asi, pero no te preocupes, dentro de un rato lo borro y continuo por mi cuenta.

Gracias por los consejos.