• Sábado 21 de Diciembre de 2024, 12:59

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - i82maria

Páginas: 1 [2] 3 4 5
26
C/C++ / Re: Problema Al Ejecutar Ficheros En C
« en: Miércoles 18 de Mayo de 2005, 20:15 »
Cita de: "carmamezo"
No he mirado todo el código por falta de tiempo pero te doy un consejo, cada vez que hagas un fopen comprueba que la función no te devuelva NULL, puede que al abrir algún fichero éste te devuelva NULL y luego al hacer fprintf() como el puntero a FILE vale NULL te de un error de ejecución.
Código: Text
  1.  
  2. FILE *pf;
  3.  
  4. if((pf=fopen(nombre_fichero,"r"))==NULL)
  5. {
  6. system("Cls");
  7. printf("\n\n\t\aERROR el fichero %s no se puede abrir.",nombre_fichero);
  8. getchar();
  9. }
  10.  
  11.  
Haz esto cada vez que hagas un fopen y así sabrás si los ficheros se abren bien o no.  Piensa que cuando abres para leer el fichero debe existir, mientras que para escribir y añadir el fichero si no existe se crea.
Un saludo. :lightsabre:
Gracias por tu ayuda, resolvi mi problema de ejecucion.

27
C/C++ / Re: Problemas Al Leer Cadenas, Con Scanf
« en: Miércoles 18 de Mayo de 2005, 19:51 »
Cita de: "iori2029"
Perdon por la tardanza, fgets es similar a gets, es decir ambas son funciones para cadenas de caracteres(texto), y si , puedes usar fgets en lugar de fscanf, nada mas que creo que fgets interpreta los datos como una cadena(creo), ademas tienes que pasarle el numero de caracteres que quieres que te lea, el archivo y creo que el buffer do :devil: nde se va a guardar la cadena.
Gracias por responder, pero insisto, se trata de un fichero tipo texto, y yo no se cual es el tamaño del buffer, se necesita leer linea a linea, el fichero.
Para q no se amontonen las palabras y se metan en el campo diferente.
De todos modos gracias por tu ayuda.

28
C/C++ / Re: Problemas Al Leer Cadenas, Con Scanf
« en: Lunes 16 de Mayo de 2005, 18:12 »
Cita de: "iori2029"
Ya probaste con fgets.

fgets te permite leer cadenas con espacios, creo que su uso es mas o menos asi

fgets(fichero,cadena para guardar texto, numero de caracteres a guardar);

Mas o menos, creo que va asi con esos argumentos,ahora como dice el cuate de arriba, para estructuras es mejor usar fread y fwrite, ademas te sirven para escribirlos de modo binario, no solo texto.

Espero que te sirva adios :)
Gracia por responder lo primero, pero una pregunta, se trata de un fichero texto, se puede usar la funcion fgets, para un fichero texto, como quedaria, quiero decir, entonces la linea del fscanf, tengo q sustituirla por una de fgets,.
Gracias

29
C/C++ / Problemas Al Leer Cadenas, Con Scanf
« en: Viernes 13 de Mayo de 2005, 21:29 »
Hola, buenas, vereis, tengo un problema, a la hora de mostrar el contenido de un fichero en consola. La cosa es la siguiente. Yo tengo q mostrar en pantalla, las personas q hay en un fichero de clientes de coches. Pues bien, lo hago asi:
Código: Text
  1.  
  2. void verPropietarios()
  3. {
  4.   FILE *pf;
  5.   struct propietario p1;
  6.   pf = fopen("propietarios.txt", "r"); /*se abre para lectura*/
  7.  
  8.   if(pf == NULL)
  9.   {
  10.     printf("\n No existe el archivo\n");
  11.     exit (-1);
  12.   }
  13.  
  14.   /*comienzo a leer datos hasta que llegue al final*/
  15.  
  16.   while(fscanf(pf, "%s %s %s %s", p1.nombre, p1.apellidos, p1.NIF, p1.direccion) == 4)
  17.   {
  18.      escribirPropietario(p1);
  19.   }
  20.   fclose(pf);
  21. }
  22.  
  23.  

El problema está q cuando me los muestra, me coge para el nombre una palbra, no dos. Es decir, si le meto:
Nombre: Maria Jose
Apellidos: Perez Muñoz
Me troca los campos, y me muestra
Nombre:Maria Apellidos:Jose NIF: Perez.
Entendeis lo que quiero decir no, yo se q esto pasa por leer los campos con scanf, pero es q no se como leerlos, ya q se trata de ficheros texto, si alguien puede decirme como puedo solucionar este problema. Gracias

Código: Text
  1.  
  2. void escribirPropietario(struct propietario p1)
  3. {
  4.   printf("Nombre: %s  Apellidos: %s NIF: %s  Direccion: %s\n", p1.nombre, p1.apellidos, p1.NIF, p1.direccion);
  5. }
  6.  
  7.  

30
C/C++ / Re: Problema Al Ejecutar Ficheros En C
« en: Miércoles 11 de Mayo de 2005, 13:18 »
Cita de: "carmamezo"
No he mirado todo el código por falta de tiempo pero te doy un consejo, cada vez que hagas un fopen comprueba que la función no te devuelva NULL, puede que al abrir algún fichero éste te devuelva NULL y luego al hacer fprintf() como el puntero a FILE vale NULL te de un error de ejecución.
Código: Text
  1.  
  2. FILE *pf;
  3.  
  4. if((pf=fopen(nombre_fichero,"r"))==NULL)
  5. {
  6. system("Cls");
  7. printf("\n\n\t\aERROR el fichero %s no se puede abrir.",nombre_fichero);
  8. getchar();
  9. }
  10.  
  11.  
Haz esto cada vez que hagas un fopen y así sabrás si los ficheros se abren bien o no.  Piensa que cuando abres para leer el fichero debe existir, mientras que para escribir y añadir el fichero si no existe se crea.
Un saludo. :lightsabre:
Gracias por rsponderme lo primero, he cogido nota de lo que me has dicho, pero aún asi sigue dandome error al ejecutar el programa. Es un error segun me dice, del fscanf de la funcion buscarporMatri, dice stream ! = NULL. Si estas interesado en ayudarme, dame tu correo, y  te envio el codigo entero.
Gracias de nuevo.

31
C/C++ / Re: Problema Al Ejecutar Ficheros En C
« en: Miércoles 11 de Mayo de 2005, 02:40 »
Cita de: "fuhrer"
Hola que tal.

La verdad no veo cual pueda ser el error, tal ves hubiera sido de más ayuda que especificaras que mensaje obtienes.

Si quieres pasarme tu código como dices para ver que es lo que sucede, así como el archivo del cual estas leyendo, espero poder ayudarte.

Hasta luego.
Gracias el codigo es este:

El archivo de funciones es este:

[CODE]
#include "cabecera.h"

int menu()
{
  int opcion;
  printf("1. Asegurar vehiculo\n");
  printf("2. Consultar fichero de coches\n");
  printf("3. Consultar fichero de clientes\n");
  printf("4. Consultar datos de un vehiculo y su propietario dada su matricula\n");
  printf("5. Consultar vehiculo dado el Nif Del cliente\n");
  printf("*****************************");
  printf("\nIntroduzca una opcion: ");
  scanf("%d", &opcion);
 
  //system("clear");
  return opcion;
}
 
void anyadirPropietario(char *fichero, struct propietario p1)
{
   FILE *pf;
   pf = fopen(fichero, "a");
   
   fprintf(pf, "%s %s %s %s\n", p1.nombre, p1.apellidos, p1.NIF, p1.direccion);
   
   fclose(pf);
}

void escribirVehiculo(struct vehiculo c1)
{
  printf("Tipo: %s  Matri: %d Coste: %3.2f \n", c1.tipo, c1.matri,c1.coste);
}

void escribirPropietario(struct propietario p1)
{
  printf("Nombre: %s  Apellidos: %s NIF: %s  Direccion: %s\n", p1.nombre, p1.apellidos, p1.NIF, p1.direccion);
}

void escribirDatosVePro(struct vehiculoPropietario aux)
{
  printf("Matricula: %d NIF: %s\n", aux.matri, aux.NIF);
}


 
void verPropietarios(char *fichero)
{
  FILE *pf;
  struct propietario p1;
  pf = fopen(fichero, "r"); /*se abre para lectura*/
 
  /*comienzo a leer datos hasta que llegue al final*/
 
  while(fscanf(pf, "%s %s %s %s", p1.nombre, p1.apellidos, p1.NIF, p1.direccion) == 4)
  {
     escribirPropietario(p1);
  }
  fclose(pf);
}

void verVehiculos(char *fichero)
{
  FILE *pf;
  struct vehiculo c1;
  pf = fopen(fichero, "r"); /*se abre para lectura*/
 
  /*comienzo a leer datos hasta que llegue al final*/
 
  while(fscanf(pf, "%s %d %f", c1.tipo, &c1.matri, &c1.coste) == 3)
  {
     escribirVehiculo(c1);
  }
  fclose(pf);
}


void verVePro(char *fichero, struct vehiculoPropietario nueva)
{
   FILE *pb;
   pb = fopen(fichero, "rb"); /*se abre para lectura*/
   
   /*comienzo a leer los datos hasta que llegue al final*/

   while(fread(&nueva, sizeof(struct vehiculoPropietario), 1, pb)==1)

   /*COmprueba que no ha llegado al final del fichero*/

   {
      /*HAY que comprobar que no este marcado como borrado*/
     /* if(coche1.borrado == 0)*/
        escribirDatosVePro(nueva); /*muestra el registro por pantalla*/
   }
   fclose(pb);
}
//leer el fichero y comprobar q no esta la matricula


void anyadirVehiculo(char *fichero, struct vehiculo c1)
{
 
   FILE *pf;
   pf = fopen(fichero, "a");

   
 
     fprintf(pf, "%s %d %3.2f\n", c1.tipo, c1.matri, c1.coste);

   /*printf("%s %d %f %s\n", coche.tipo, coche.matri, coche.coste);*/

   fclose(pf);
}

void anyadirVePro(char *fichero, struct vehiculoPropietario aux)
{
  FILE *pb;
  pb = fopen(fichero, "ab"); /*abre el fichero para añadir*/
 
  /*guarda los datos en el fichero*/

  fwrite(&aux, sizeof(struct vehiculoPropietario), 1, pb);
  fclose(pb);
}
 
int existeFichero(char *fichero)
{
   FILE *pf;
   
   pf = fopen(fichero, "r"); /*abre fichero para lectura*/
   
   if(pf == NULL) /*el fichero no existe*/
   {
   
      return 0;
   }
   else /*el fichero si existe*/
   {
      fclose(pf);
      return 1;
   }
}
 

int buscarPorMatri(char *fichero, int matri, struct vehiculo *coche)
{
  FILE *pfichero;
  int salir = 0;
  int encontrado = 0;
  int cont;
  struct vehiculo auxiliar;
  //struct vehiculo *coche;
 
  pfichero = fopen(fichero, "r"); /*abrimos para lectura*/
   while(salir ==0)
  {
   cont = fscanf(pfichero,"%s %d %f", auxiliar.tipo, &auxiliar.matri, &auxiliar.coste);
   
   /*en la variable cont almacenamos el numero de campos del fichero*/
   
   if(cont!=3) /*hemos llegado al final del fichero*/
      salir = 1;
    else
       if(auxiliar.matri == matri) /*ha encontrado el registro*/
       {
         encontrado = 1;
      salir = 1;
      *coche = auxiliar; /*almacena en coche el registro encontrado*/
      }
   
   }
   fclose(pfichero);
   return encontrado;
}
 
int buscarPorNIF(char *fichero, char *auxNIF)
{
  FILE *pf;
  int encontrado = 0; /*variables auxiliar para la busqueda*/
  struct propietario auxiliar;
 
  pf = fopen(fichero, "r"); /*abrimos para lectura*/
 
  while(fscanf(pf,"%s %s %s %s", auxiliar.nombre, auxiliar.apellidos,  auxiliar.NIF, auxiliar.direccion)==4)
   {
 
   if(strcmp(auxiliar.NIF, auxNIF)==0) /*ha encontrado el registro*/
   {
      escribirPropietario(auxiliar); /*se escriben sus datos*/
      encontrado = 1;
        }
    }
   fclose(pf);
   return encontrado;
 }

struct propietario introducirDatosPropietario()
{
   struct propietario aux;
    printf("\n Introducir nombre: ");
    gets(aux.nombre);
    printf("\n Introducir apellidos: ");
    gets(aux.apellidos);
    printf("\nIntroducir NIF: ");
    gets(aux.NIF);
    printf("\nIntroducir direccion: ");
    gets(aux.direccion);
    return aux;
}


int existePropietario(char *fichero, char *auxNIF, struct propietario p1)
{
   FILE *fp;
   int encontrado;

   fp  = fopen(fichero, "r");

   encontrado = buscarPorNIF(fichero, auxNIF);

   if(!encontrado)
   {
      return 0;
   }
   else {
      printf("\nEl propietario ya existe\n");
      fclose(fp);
      return 1;
   }
}


int existeVehiculo(char *fichero, int matri, struct vehiculo c1)
{
   FILE *fp;
   int encontrado;


   fp = fopen(fichero, "r"); //se abre para lectura


      encontrado = buscarPorMatri(fichero, matri, &c1);
      if(!encontrado)
      {
         return 0;
      }
      else{
         printf("\n El vehiculo ya existe\n");
         fclose(fp);
         return 1;
      }
   
}

         
   




struct vehiculo introducirDatosVehiculo()
{
   struct vehiculo aux;


    printf("\n Introducir tipo: ");
    scanf("%s", aux.tipo);
    getchar();
    /*printf("\n %s", aux.tipo);*/
   
    printf("\n Introducir matricula: ");
    scanf("%d", &aux.matri);
    getchar();
    /*printf("\n %d" ,aux.matri);*/
   
    printf("\nIntroducir coste: ");
    scanf("%f", &aux.coste);
    getchar();
    /*printf("\n %.3f", aux.coste);*/
 
   
    return aux;

   printf("\n La matricula es: %d", aux.matri);



   //crear una funcion q compruebe si existe o no el vehiculo
 
}
   
   /*
void borrarVehiculo(char *fichero, int matri)
{
 FILE *pf1, *pf2;
 struct vehiculo aux;
 
 pf1 = fopen(fichero, "r"); /*se abre para lectura el fichero original*
 
 pf2 = fopen("temporal.txt", "w"); /*se abre para escritura el fichero temporal*
 
 /*Se recorre el fichero original y los registros que no hay que borrar se psan
 al temporal*
 while(fscanf("%s %d %f", &aux.tipo, aux.matri, aux.coste) == 3)
 {
    if (aux.matri !=matri)
   
   fprintf(pf2, "%s %d %f\n", aux.tipo, aux.matri, aux.coste);
 }
   fclose(pf1);
   fclose(pf2);
   
   /*se borra el fichero original*
   remove(fichero);
   
   /*se renombra el temporal*
   rename("temporal.txt",fichero);
}
 

void borrarPropietario(char *fichero, char NIF)
{
 FILE *pf1, *pf2;
 struct propietario aux;
 
 pf1 = fopen(fichero, "r"); /*se abre para lectura el fichero original*
 
 pf2 = fopen("temporal.txt", "w"); /*se abre para escritura el fichero temporal*/
 
 /*Se recorre el fichero original y los registros que no hay que borrar se psan
 al temporal*
 while(fscanf("%s %s %s %s", aux.nombre, aux.apellidos, aux.NIF, aux.coste) ==
 4)
 {
    if (strcmp(aux.NIF, NIF)!=0)
   
   fprintf(pf2, "%s %s %s %s\n", aux.nombre, aux.apellidos, aux.NIF,
   aux.direccion);
 }
   fclose(pf1);
   fclose(pf2);
   
   /*se borra el fichero original*
   remove(fichero);
   
   /*se renombra el temporal/
   rename("temporal.txt",fichero);
}
          
   
*/
[CODE]
El de cabecera.h es este

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


struct vehiculo
{
     char tipo[7];
     int matri;
     float coste;
};

struct propietario
{
   char nombre[10];
   char apellidos[30];
   char NIF[10];
   char direccion[30];
};

struct vehiculoPropietario
{
   int matri;
   char NIF[10];
   
};

int menu();


void anyadirPropietario(char *fichero, struct propietario p1);
void anyadirVehiculo(char *fichero, struct vehiculo c1);
void anyadirVePro(char *fichero, struct vehiculoPropietario aux);
int existeFichero(char *fichero);
int buscarPorMatri(char *fichero, int matri, struct vehiculo *coche);
int buscarPorNIF(char *fichero, char *auxNIF);
void escribirDatosVePro(struct vehiculoPropietario aux);
void escribirPropietario(struct propietario p1);
void escribirVehiculo(struct vehiculo c1);

int existeVehiculo(char *fichero, int matri, struct vehiculo c1);
int existePropietario(char *fichero, char *auxNIF, struct propietario p1);


struct propietario introducirDatosPropietario();
struct vehiculo introducirDatosVehiculo();
void verPropietarios(char *fichero);
void verVehiculos(char *fichero);
void verVePro(char *fichero, struct vehiculoPropietario nueva);

Y el ppal.c es este

[CODE]
#include "cabecera.h"

struct vehiculoPropietario nueva;  
main(void)
{

//FILE *fictxt;
int opcion; /*variables para opcion del menu*/
int salir = 0; /*variable auxiliar usada en la busqueda*/
//int encontrado = 0; /*variable q indica si el registro se ha encontrado*/
int existe; /*variable auxiliar que indica si el fichero existe*/
int existe1;
char fichero[15];
struct vehiculo coche1;
struct propietario persona1;
//struct vehiculoPropietario nueva;

//system("clear");

/*introduccion del nombre del fichero para trabajar*/
printf("\nIntroduzca el nombre del fichero: ");
gets(fichero);



/*menu de opciones del programa*/
do{
   do{
     opcion = menu();
    }while(opcion <1 || opcion >3);
     switch(opcion)
     {
      case 1: /*asegurar un vehiculo*/
      {
         
         coche1= introducirDatosVehiculo();
         
            /*se añade el registro ya que seria el primero*/
            existe  = existeVehiculo(fichero, coche1.matri, coche1);
                 

         if(existe) /*el coche ya existe*/
          {
                  printf("\nVehiculo ya existente\n");
               exit(-1);
         }

               /*se añade el registro ya q seria el primero*/
               anyadirVehiculo(fichero, coche1);
                  printf("Vehiculo añadido. Pulse intro para seguir\n");
               
            
               persona1 = introducirDatosPropietario();
               existe1 = existePropietario(fichero, persona1.NIF, persona1);
         
            if(existe1)
            {
               printf("\n EL propiestario ya existe\n");
               exit(-1);
            }

               
            
                   anyadirPropietario(fichero, persona1);
                      anyadirVePro(fichero, nueva);
                   printf("\nPropietario añadido. Pulse intro para seguir\n");
            
               
              
        getchar();
    break;
       }
     
     case 2: /*visualizar todos los vehiculos asegurados*/
     {
       /*comprueba si existe el fichero*/
       existe = existeFichero(fichero);
       if(existe == 1) /*el fichero existe*/
       {
         verVehiculos(fichero); /*muestra los registros del fichero vehiculos*/
         printf("Datos leidos. Pulse INtro para continuar\n");
      }
      else /*el fichero no existe*/
      {
       printf("EL fichero de vehiculos no existe. Pulsa intro para ontinuar\n");
      }
      getchar();
      getchar();
   break;
      }
           
     
     case 3: /*visualizar todos los propietarios de vehiculos*/
      {
       /*comprueba si existe el fichero*/
       existe = existeFichero(fichero);
       if(existe == 1) /*el fichero existe*/
       {
         verPropietarios(fichero); /*muestra los registros del fichero vehiculos*/
      printf("Datos leidos. Pulse INtro para continuar\n");
      }
      else //el fichero no existe
      {
         printf("\nEL fichero de propietarios no existe. Pulsa intro para continuar\n");
      }
      getchar();
      getchar();
      break;
      }
       case 0: /*salida del programa*/
       break;
     
      }

}while(opcion!=3);
 
}

La practica va sobre un fichero de coches y otro de propietarios
y primero hay q introducir los coches, sin q se repita la matricula y luego los propietarios.< Muchas gracias, por responderme, pq estoy ya desesperada.
Es q en si, no me da ningun msj, de warning ni nada, es al ejecutar.

32
C/C++ / Problema Al Ejecutar Ficheros En C
« en: Miércoles 11 de Mayo de 2005, 02:21 »
Hola tengo que hacer una practica de ficheros  de c, estoy yendo poco a poco. Y bueno no es plande ponerle todo el codigo, solo les pondre, donde me dice el debug q me da error, dice q es en el fscanf y yo no sé por que.

int buscarPorMatri(char *fichero, int matri, struct vehiculo *coche)
{
  FILE *pfichero;
  int salir = 0;
  int encontrado = 0;
  int cont;
  struct vehiculo auxiliar;
  //struct vehiculo *coche;
 
  pfichero = fopen(fichero, "r"); /*abrimos para lectura*/
   while(salir ==0)
  {
   cont = fscanf(pfichero,"%s %d %f", auxiliar.tipo, &auxiliar.matri, &auxiliar.coste);
   
   /*en la variable cont almacenamos el numero de campos del fichero*/
   
   if(cont!=3) /*hemos llegado al final del fichero*/
      salir = 1;
    else
       if(auxiliar.matri == matri) /*ha encontrado el registro*/
       {
         encontrado = 1;
      salir = 1;
      *coche = auxiliar; /*almacena en coche el registro encontrado*/
      }
   
   }
   fclose(pfichero);
   return encontrado;
}

Yo ejecuto el programa, y se sale ,  y el debug me dice q es el fscanf de estga funcion, si alguien puede ayudarme, y quiere ver el codigo entero que me lo diga. Gracias, necesito consejos.

33
C/C++ / Re: Estructuras De Datos Dinamicas En C
« en: Miércoles 15 de Diciembre de 2004, 11:34 »
Cita de: "mgitano2001"
No lei con mucha atencion el codigo, pero note que cuando agregar un elemento en la cola, solamente estas pasando un puntero (el final), si usas cola normar (una estructura tipica, no una cola circular ni nada de eso), tenes que pasar los dos punteros, aca va un ejemplo:

struct cola {
         int dato;
         struct cola *next;
};

int enqueue(struct cola **head, struct cola **tail, int dato)
{
          struct cola *nuevo = (struct cola *) malloc(sizeof(struct cola));

          if (!nuevo)
               return -1; /* No hay memoria suficiente */

          nuevo->dato = dato;
          nuevo->next = NULL;

          if (*head == NULL)
                  *head = nuevo;
          else
                  (*tail)->next = nuevo;

           *tail = nuevo;
           return 0;           /* Todo concluyo bien */
}


(Consejo: Trata de dibujar todo, es mas facil de entender, "Si puedes dibujarlo puedes organizarlo") Saludos!!!,
Mgitano2001
Entonces segun tu me dices tengo que usar ds punteros, el final y la cabeza de la cola, no?. Asi me funcionará bien el programa?. Por favor, respondeme es importante, tengo que tenerlo echo para esta tarde.
Gracias por haberme respondido antes.

34
C/C++ / Re: Principiante, Buscando Ayuda.
« en: Martes 14 de Diciembre de 2004, 20:35 »
Cita de: "Garrisoft"
Wenas a todos, solo pido porfavor si alguien sabe de algun manual que este bien para principiantes y también que tenga ejercicios y sus correcciones, y si puede ser algo de algoritmos dibujados.
Tiene que ser lo mas basico, para una persona que no ha vista en su vida una linea de codigo.
Espero que me podais ayudar, muchas gracias. ;)
Hola buenas, bueno manuales hay muchos mira en la pagina de
http://www.ulpgc.es/otros/tutoriales/mtutor/indice.html
aqui hay un tutorial, para principiantes, y en el rincondelvago.com, hay otro que se llama rincondelc.Pones en el google, rincon del C.
Y te sale, suerte
SI necesitas orta cosa, pa eso estamos
 :hola:

35
C/C++ / Estructuras De Datos Dinamicas En C
« en: Martes 14 de Diciembre de 2004, 12:59 »
Hola a todos, estoy haciendo una practica de colas en C, otra de pilas, y ambas me dan error de ejecucion de memoria, si alguien tiene tiempo, y puede ayudarme, es que no se donde esta el fallo,es muy importante.Adjunto aqui el codigo de cada una de ellas.Ruego me contesten lo antes posible, gracias.
[CODE]
/*colas.h*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <conio.h>

struct cola{
   char fichero[31];
   int tamanyo;
   char usuario[31];
   int ident;
   struct cola *sig;
};
void crear(struct cola **frente);
int vaciaCola(struct cola *frente);
void introducirDatos(struct cola *datos);
void anyadir(struct cola **final);
struct cola *nuevoElemento();
void eliminar(struct cola **frente);
void visualizar(struct cola *actual);
void imprimirTrabajo(struct cola **frente);
void listar(struct cola **frente);
int presentaMenu(void);

/*colas.c*/
#include "colas.h"

main()
{
   int opcion;
   struct cola *frente, *final;

   do{

      crear(&frente);
      do{
         opcion = presentaMenu();

       }while(opcion <0 || opcion > 4);
     
      switch(opcion)
      {
   
         case 1: /*Añadir un trabajo*/
                anyadir(&final);
            break;
         case 2: //Imprimir un trabajo
            imprimirTrabajo(&frente);
            break;
         case 3: //listar trabajos
            listar(&frente);
            break;
         case 4: //eliminar un trabajo
            eliminar(&frente);
            break;
         case 0:
            printf("\n\n\nADIOS\n");
            break;
      }
   }while(opcion);
}


      
void crear(struct cola **frente)
{
   *frente = NULL;
}

int vaciaCola(struct cola *frente)
{
   if(frente == NULL)
      return 1;
   else
      return 0;
}

void introducirDatos(struct cola *datos)
{
   
   printf("\nIntroduzca el nombre del fichero: ");
   gets(datos->fichero);
   fflush(stdin);

   printf("\n Introduzca el tamanyo: ");
   scanf("%d", &datos->tamanyo);
   fflush(stdin);

   printf("\nIntroduzca el nombre de usuario: ");
   gets(datos->usuario);
   fflush(stdin);

   printf("\nIntroduzca el identificador: ");
   scanf("%d", &datos->ident);
   getche();
   
}

int presentaMenu(void)
{
   int opcion;
    printf("EJEMPLO DE MANEJO DE COLAS\n");
    printf("-------------------------\n\n");
     printf("1.- Anyadir un trabajo a la cola\n");
     printf("2.- Imprimir un trabajo\n");
     printf("3.- Listar los trabajos\n");
     printf("4.- Eliminar un trabajo\n");
     printf("0.- TERMINAR.\n\n\n");
     printf("Introduce una opcion: ");
     scanf("%d",&opcion);
     fflush(stdin);
    return opcion;
}

struct cola *nuevoElemento()
{
   struct cola *a;
   a = (struct cola *) malloc(sizeof(struct cola));
   return a;
}

void anyadir(struct cola **final)
{
 struct cola *nuevo= NULL;
 struct cola *aux = NULL; //almacena el posterior al que se inserta

 
   printf("AÑADIR TRABAJOS\n");
   printf("**********************\n\n");
 
  nuevo = nuevoElemento();
 introducirDatos(nuevo);


 if(vaciaCola(*final))
 {
    nuevo->sig = *final;
    *final = nuevo;

 }
 else
 {
    aux = *final;
    while((aux->sig) !=NULL){
       aux = aux->sig;
    }
    if(nuevo !=NULL)
    {
       aux->sig = nuevo;
       nuevo->sig =NULL;
    }
 }
}


void eliminar(struct cola **frente)
{
   struct cola *borrar, *ant = NULL;
   int id;

   system("clear");
   printf("ELIMINAR TRABAJOS\n");
   printf("**********************\n\n");
   printf("\n Introduzca el identificador de trabajo: ");
   scanf("%d", &id);


   if(vaciaCola(*frente))
   {
      printf("\nLa cola esta vacia\n");
      exit(0);
   }
   else
   {
      while(borrar!=NULL && borrar->ident == id)
         {
         if(ant == NULL){
            borrar = *frente;
            *frente = (*frente)->sig;
            free(borrar);
            }
            else{
               ant->sig = borrar->sig;
               free(borrar);
               }
         }
            //si son distintos
         ant = borrar;
         borrar = borrar->sig;

   }
}


void visualizar(struct cola *actual)
{
    printf("\n Fichero..................: %s", actual->fichero);
     printf("\n Tamanyo en bytes.........: %d", actual->tamanyo);
     printf("\n Nombre de usuario........: %s", actual->usuario);
     printf("\n Identificador............: %d", actual->ident);
   actual = actual->sig;

   
}

void listar(struct cola **frente)
{
   struct cola *actual;
   system("clear");
   printf("LISTAR TRABAJOS DE LA COLA\n");
   printf("**********************\n\n");
   
   actual = *frente;
   if(!vaciaCola(*frente))
   {
      while(actual!=NULL)
      {
         visualizar(actual);
         printf("\n");
         fflush(stdin);
         printf("\nPulse intro para continuar....");
         getchar();

         actual = actual->sig;
      }
   }
}

void imprimirTrabajo(struct cola **frente)
{
   struct cola *borrar;
   system("clear");
   printf("IMPRIMIR TRABAJOS\n");
   printf("**********************\n\n");
   
   borrar = *frente;
   visualizar(borrar);
      fflush(stdin);
      printf("\nPulse intro para continuar....");
      getchar();
    *frente = (*frente)->sig;
   free(borrar);
}

/*pilas.h*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define ASCENDENTE 1
#define DESCENDENTE 0

struct pila{
   char nombre[15];
   int edad;
   struct pila *sig;
};

void crearPila(struct pila **cima);
int pilaVacia(struct pila *cima);
void apilar(struct pila **cima);
void desapilar(struct pila **cima);
void listarPila(struct pila *cima);
//void eliminarPila(struct pila **cima, char *nombre);
void liberar(struct pila **cima);
int menu(void);

struct pila *nuevoElemento();
void visualizar(struct pila *cima);
void leerDatos(struct pila *dat);
void verCima(struct pila *cima);
void top(struct pila *cima,char *nom, int *ed);

/*pilas.c*/
#include "pilas.h"

main(void)
{
   struct pila *cima;
   int opcion;
   do{
   crearPila(&cima);

   do
   {
      opcion = menu();
      
   }while(opcion <0 || opcion >5);

      switch(opcion)
      {
      case 1: //añadir en la pila
         apilar(&cima);

         break;
      case 2: //ver la cima de la pila
         verCima(cima);
         break;
      case 3: //Desapilar un elemento de la cima
         desapilar(&cima);
         break;
      case 4: //Listar la pila
         listarPila(cima);
         break;
   
      case 5: //Liberar la memoria de la pila
         liberar(&cima);

         break;
      }
   }while(opcion);
}

int menu(void)
{
   int opcion;

   printf("******** EJEMPLO DE PILAS **********\n");
   printf("1. Añadir en la pila\n");
   printf("2. Cima de la pila\n");
   printf("3. Desapilar un elemento de la pila\n");
   printf("4. Listar la pila\n");
   printf("5. Liberar la memoria ocupada por la pila\n\n");
   printf("0. TERMINAR\n\n");
   printf("\nIntroduce una opcion: ");
   scanf("%d",&opcion);
   fflush(stdin);

   return opcion;
}
/************************** Funcion crearPila() *********************/
/* Propósito.........: Crea la pila.
   Parametro.........: Puntero cima d ela pila por referencia
   Devuelve..........: Nada
   */
/********************************************************************/

void crearPila(struct pila **cima)
{
   *cima = NULL;
}

/************************** Funcion pilaVacia() *********************/
/* Propósito.........: Comprueba si la pila está vacia
   Parametro.........: Puntero cima de la pila por valor
   Devuelve..........:  SI si la pila está vacia
                  NO si la pila no lo está.
   */
/********************************************************************/


int pilaVacia(struct pila *cima)
{
   if(cima == NULL)
      return 1;
   else
      return 0;
}


void leerDatos(struct pila *dat)
{
   printf("\nIntroduzca el nombre...: ");
   gets(dat->nombre);
   fflush(stdin);

   printf("\nIntroduzca la edad...: ");
    scanf("%d", &dat->edad);
   fflush(stdin);

    dat->sig = NULL;
}

struct pila *nuevoElemento()
{
   struct pila *a;
   a = (struct pila *) malloc(sizeof(struct pila));
   return a;
}

/************************** Funcion apilar() *********************/
/* Propósito.........: Añade elementos a la pila
   Parametro.........: Puntero cima de la pila por referencia
   Devuelve..........:  Nada
   */
/********************************************************************/

void apilar(struct pila **cima)
{
   struct pila *nuevo;
   nuevo = nuevoElemento();
   leerDatos(nuevo);

   nuevo->sig = *cima;
   *cima = nuevo;
}
/************************** Funcion desapilar() *********************/
/* Propósito.........: Elimina elementos de la cima de la pila
   Parametro.........: Puntero cima de la pila por referencia
   Devuelve..........:  nada
   */
/********************************************************************/

void desapilar(struct pila **cima)
{
   struct pila *borrar;
    if (pilaVacia(*cima))
      printf("\n La pila está vacia\n");
   else
   {

   borrar = *cima;
   *cima = borrar->sig;
   free(borrar);
   }
   
}
/************************** Funcion eliminarPila() *********************/
/* Propósito.........: Se encarga de eliminar un elemento por su nombre
   Parametro.........: Puntero cima de la pila por valor, y el nombre
                  del alumno que queremos que se borre.
   Devuelve..........:  Nada.
   Llamadas... a la funcion crearPila, apilar, y desapilar  
*/
/********************************************************************/


/************************** Funcion desapilar() *********************/
/* Propósito.........: Muestra por pantalla los elemento s de la pila
                  desde la cima hasta la base
   Parametro.........: Puntero cima de la pila por valor
   Devuelve..........:  nada
   */
/********************************************************************/
void visualizar(struct pila *cima)
{
   struct pila *actual;
   actual = cima;
   while(actual!=NULL)
   {
      printf("Nombre.........%s\n ", actual->nombre);
      printf("Edad...........%d\n ", actual->edad);
      actual = actual->sig;
   }
}

/************************** Funcion listarPila() *********************/
/* Propósito.........: Muestra por pantalla los elementos de la pila.
   Parametro.........: Puntero cima de la pila por valor.
   Devuelve..........:  Nada.
   Llamada ... a la funcion visualizar()
   */
/********************************************************************/
void listarPila(struct pila *cima)
{
   if(pilaVacia(cima))
      printf("\n\nLa pila esta vacia\n");
   else
   {
      printf("\nLISTADO DEL ESTADO DE LA PILA\n");
   visualizar(cima);
   }
   getchar();
}


void liberar(struct pila **cima)
{
   struct pila *actual, *aux;
   actual = *cima;
   while(actual!=NULL)
   {
      aux = actual->sig;
      free(actual);
      actual = aux;
   }
   *cima = NULL;
}

void verCima(struct pila *cima)
{
   char nom[15];
   int ed;

   if (pilaVacia(cima))
      printf("\n\nLa pila está vacía.\n");
   else
   {
      top(cima,nom,ed);

         printf("\n\nValor de la cima: %s\n",nom);
     
         printf("\n\nValor de la cima: %d\n",ed);
   }
}
void top(struct pila *cima,char *nom, int *ed)
{
   /* si la pila está vacía no hacemos nada */
   if (pilaVacia(cima))
      exit (0);

   /* proceso normal (pila no vacía) */
   strcpy(*nom, cima->nombre);
   
   *ed = cima->edad;
 
}

36
C/C++ / Re: Error De Ejecución En Memoria
« en: Domingo 12 de Diciembre de 2004, 19:46 »
Cita de: "JuanK"
Hola,
lamentablemente he estado muy ocupado,
y aunque he recibido tu correo lo ciertyo es que no he teniodo tiempo de seguirlo revisando.

Tratare de hacer algo más tarde pero es incierto a que hora comenzare a  hacerlo debido a algunas cosas que tengo que hacer.

en este momento aca enm colombia son las 13:00.
Gracias de todos modos, entiendo no sabia qu eres colombiano. Aqui son las 8 de la tarde, cuando puedas las miras, luego veo si me has contestado. Gracias
Y perdon por las molestias.
Saludos desde ESpaña

37
C/C++ / Re: Error De Ejecución En Memoria
« en: Sábado 11 de Diciembre de 2004, 22:39 »
Cita de: "JuanK"
ok, aunque a mi me funcinaba bien.

No se si ya has arreglado lo que te comente, y por favor adjuntame el codigo comlpeto en un archivo .zip-
Gracias voy a cenar, ahora despues vuelvo.

38
C/C++ / Re: Error De Ejecución En Memoria
« en: Sábado 11 de Diciembre de 2004, 21:31 »
Cita de: "JuanK"
hOLA.

he revisado un poco
Y paso a paso en orden de ejecucion  y de opciones
y tienes varios inconvenientes asi que solo te dire hasta donde encontre los primeros fallos graves, corrigelos, busca mas errores y si tienes dudas pregunta de nuevo, pero eso si te pido el  favor de que antes de preguntar le hagas seguimiento a tu programa ejecutandolo paso a paso ya que las cosas que encontre las encontre haciendolo asi y eso lo hubieses podido hacer tu misma.

El fflush(stdin) no siempre funciona como quisieramos asi que cada vez que quieras capturar algun dato trata de hacer algo como esto, pero no el fflush(stdin)
Código: Text
  1.  
  2. gets(NULL);
  3. scanf(...);
  4.  
  5.  

Ahora si te fijas en este pedacito de codigo:
Código: Text
  1. case 1: /*Insercion al principio*/
  2.     introducirDatos(nombre, ape1, ape2, edad);
  3.     /*comprobamos si existe la persona*/
  4.     existe = buscarPersona(cabeza, ape1);
  5.  
  6.     if(!existe) //existe == NULL
  7.     {
  8.         do
  9.         {
  10.             insertarPrincipio(&cabeza, nombre,ape1, ape2,edad);
  11.             printf(&#34;&#092;n Persona insertada&#34;);
  12.             printf(&#34;&#092;n&#092;n&#9488;Desea introducir otra persona? (S/N): &#34;);
  13.             gets(NULL);//JUANK
  14.             scanf(&#34;%c&#34;, &resp);
  15.  
  16.         }while(resp == 's' || resp =='S');
  17.  
  18.         mostrarLista(cabeza);
  19.         getchar();
  20.     }
  21.  

Preguntas que si se desea insertar mas personas ....
pero si seleccionas que si volvera a realizar la funcion insertarPrincipio(...)
sin antes haber realizado la funcion introducirDatos(...) lo cual hara que vuelva a insertar el mismo nodo.

Espero te sea de ayuda y si tienes más dudas solo pregunta. :comp:
Gracias verás ya he modificado la funcion
void introducirDatos(struct lista *dat)

{
          printf("\nIntroduzca el nombre => ");
        gets(dat->nombre);
        fflush(stdin);
   
          printf("\nIntroduzca el apellido1 => ");
          gets(dat->ape1);
          fflush(stdin);
       
   
          printf("\nIntroduzca el apellido2 => ");
          gets(dat->ape2);
          fflush(stdin);
       
   
          printf("\nIntroduzca la edad => ");
          scanf("%d",&dat->edad);
          fflush(stdin);
        dat->sig = NULL;
}
y me salen mejor, ya si me coge la edad. Mi problema ahora, es que inserta por apellido, ordenador, pero tengo echa una funcion para ordenar lista, y no se donde ponerla, ademas que no se proque siempre da error de ejecucion de memoria.

Te pongo aqui las dos funciones insertarporApellido1, y la nueva de ordenarLista.
void insertarPorApellido1(struct lista **cabeza,char *nombre, char *ape1, char *ape2, int edad)
{
   struct lista *aux=NULL; //almacena elemento posterior al que se inserta
   struct lista *ant =NULL; //almacena elemento anterior al que se inserta
   struct lista *nuevo = NULL; //almacena el nuevo elemento
   int encontrado  = 0;
   
   
   
   //Se reserva espacio para el nuevo elemento
   nuevo = nuevoElemento();
   introducirDatos(nuevo);
   
   if(listaVacia(*cabeza) == SI) //comprueba si la lista esta vacia
   {
   
   *cabeza = nuevo; //la cabeza será el nuevo elemento
   nuevo->sig = NULL;
   }

   else{
      aux = *cabeza;
      if(strcmp(ape1, aux->ape1)<0 ) //nuevo elemento se inserta delante de
                                      //la cabeza
      {
        nuevo->sig=*cabeza; //El siguiente de nuevo será la cabeza
       *cabeza=nuevo;
       }
      else {
         ant = *cabeza;
           aux=(*cabeza)->sig;//buscamos la posicion de insercion, se interrumpe cuando se
     //encuentra el primer elemento mayor que n o cuando se llega al final de la lista
         {
 
              while(aux!=NULL && encontrado == 0) {
                   if( strcmp( ape1, aux->ape1 ) <0 ) //hemos encontrado la posicion de insercion
                    {
                   ant->sig=nuevo;
                        nuevo->sig=aux;
                       encontrado = 1;
                     break;
                   
                     }
                   else //se actualizan los valores de ayx y ant
                       {
                       ant=aux;
                       aux=aux->sig;
                       }

             }
           if(aux == NULL){  //el elemento se inserta al final
                ant->sig = nuevo;     
            nuevo->sig = aux;
           }
       }
       }
   }
}

int listaOrdenadaApellido(struct lista *cabeza)
{
while(cabeza->sig!=NULL)
{

   if (strcmp(cabeza->ape1,cabeza->sig->ape1)>0)
   {   printf ("La lista no está ordenada por apellido1\n");
      exit (1);
   }
   cabeza=cabeza->sig;
}


return 0;
}

Voy a cenar, ahora despues de cenar, vere si mehas contestado, gracias por tu ayuda. Slaudos Mercedes.
 :rolleyes:

39
C/C++ / Re: Error De Ejecución En Memoria
« en: Sábado 11 de Diciembre de 2004, 18:59 »
Cita de: "JuanK"
ok, ya lo estoy revisando.... :comp:
Gracias espero tu respuesta, un saludo.
 :hola:

40
C/C++ / Re: Error De Ejecución En Memoria
« en: Sábado 11 de Diciembre de 2004, 17:28 »
Cita de: "JuanK"
por favor anexa el codigo completo y cuantame que has logrado revisar del problema y donde crees que sta el error.
hola Juank, ya he anezado el codigo, si no entiendes algo, dimelo, por favor, pero respondeme, q es urgente para mi, gracias.
Saludos Mercedes

41
C/C++ / Re: Error De Ejecución En Memoria
« en: Viernes 10 de Diciembre de 2004, 22:28 »
Cita de: "JuanK"
por favor anexa el codigo completo y cuantame que has logrado revisar del problema y donde crees que sta el error.
Lo primero rgracias por responderme, eeres el unico, te voy a adjuntar el codigo que llevo hecho hasta ahora.

Código: Text
  1.  
  2. /*listas.c*/
  3. #include &#34;listas.h&#34;
  4.  
  5. /* Programa principal */
  6. main()
  7. {
  8.  struct lista *existe;
  9.  struct lista *cabeza;
  10.  char nombre[15];
  11.  char ape1[20];
  12.  char ape2[20];
  13.  int edad = 0;
  14.  int opcion;
  15.  char resp;
  16.  char fichero[35];
  17.  
  18.   /* opciones */
  19. do{
  20.  
  21.  crearLista(&cabeza);
  22.      
  23.    
  24.   do{
  25.       cogerDatosTexto(&cabeza);
  26.       printf(&#34;&#092;n La lista enlazada es asi: &#092;n&#092;n&#34;);
  27.     mostrarLista(cabeza);  
  28.     presentaMenu();
  29.     printf(&#34;Introduce una opcion: &#34;);
  30.      scanf(&#34;%d&#34;,&opcion);
  31.      fflush(stdin);
  32.    
  33.    
  34.  }while(opcion &#60;0 || opcion &#62; 11);
  35.      
  36.    
  37.  
  38.       switch(opcion)
  39.       {
  40.    
  41.       case 1: /*Insercion al principio*/
  42.         introducirDatos(nombre, ape1, ape2, edad);      
  43.      /*comprobamos si existe la persona*/
  44.       existe = buscarPersona(cabeza, ape1);
  45.  
  46.       if(!existe) //existe == NULL
  47.       {
  48.        do{
  49.        insertarPrincipio(&cabeza, nombre,ape1, ape2,edad);
  50.                printf(&#34;&#092;n Persona insertada&#34;);
  51.              printf(&#34;&#092;n&#092;n¿Desea introducir otra persona? (S/N): &#34;);
  52.                          scanf(&#34;%c&#34;, &resp);
  53.                        
  54.               }while(resp == 's' || resp =='S');
  55.  
  56.      mostrarLista(cabeza);
  57.      getchar();
  58.  
  59.        
  60.        }
  61.        else
  62.          printf(&#34;&#092;n Esta persona ya existe&#34;);
  63.        visualizarNodo(existe);
  64.          getchar();
  65.          getchar();
  66.    
  67.       break;
  68.  
  69.     case 2: /*Insercion al final*/
  70.        introducirDatos(nombre, ape1, ape2, edad);    
  71.          
  72.       /*comprobamos si existe la persona*/
  73.       existe = buscarPersona(cabeza, ape1);
  74.      
  75.       if(!existe) //si no existe
  76.       {
  77.        do{
  78.        insertarFinal(&cabeza, nombre, ape1, ape2, edad);
  79.        printf(&#34;&#092;n Persona insertada&#34;);
  80.                    printf(&#34;&#092;n&#092;n¿Desea introducir otra persona? (S/N): &#34;);
  81.                          scanf(&#34;%c&#34;, &resp);
  82.                         system(&#34;clear&#34;);
  83.               }while(resp == 's' || resp =='S');
  84.      mostrarLista(cabeza);
  85.        }
  86.        else
  87.          printf(&#34;&#092;n Esta persona ya existe&#34;);
  88.        visualizarNodo(existe);
  89.          getchar();
  90.          getchar();
  91.    
  92.        break;
  93.  
  94.      case 3: /*Insertar por apellido1*/
  95.         introducirDatos(nombre, ape1, ape2, edad);  
  96.         /*comprobamos si existe la persona*/
  97.               existe = buscarPersona(cabeza, ape1);
  98.      
  99.       if(!existe)
  100.       {
  101.             do
  102.            {
  103.             insertarPorApellido1(&cabeza, nombre, ape1, ape2, edad);            printf(&#34;&#092;n&#092;n¿Desea introducir otra persona? (S/N): &#34;);
  104.             scanf(&#34;%c&#34;, &resp);
  105.             getchar();
  106.            }while(resp == 's' || resp =='S');
  107.        mostrarLista(cabeza);
  108.        getchar();
  109.        getchar();
  110.     }
  111.          
  112.     else
  113.        printf(&#34;&#092;n Esta persona ya existe&#34;);
  114.          visualizarNodo(existe);
  115.            getchar();
  116.            getchar();
  117.    
  118.       break;
  119.  
  120.      case 4: /*Borrar por apellido1*/
  121.          printf(&#34;&#092;n Introduzca el apellido a borrar: &#34;);
  122.          gets(ape1);
  123.        
  124.      //comprobamos si la persona existe
  125.         existe = buscarPersona(cabeza, ape1);
  126.        if(existe) //si existe
  127.        {
  128.           borrarPorApellido1(&cabeza, ape1);
  129.         printf(&#34;&#092;n Elemento borrado&#34;);
  130.        getchar();
  131.          mostrarLista(cabeza);
  132.        }    
  133.       else
  134.        printf(&#34;&#092;n Elemento no encontrado&#092;n&#34;);
  135.  
  136.      getchar();
  137.      getchar();
  138.      break;
  139.      
  140.    case 5:  /* Visualizar por apellido1 */
  141.  
  142.     printf(&#34;Introduzca el apellido de la persona a buscar =&#62; &#34;);
  143.     gets(ape1);
  144.           existe = buscarPersona(cabeza,ape1);
  145.  
  146.     if (!existe){
  147.       printf(&#34;&#092;nEl apellido no existe&#092;n&#34;);
  148.     }
  149.     else
  150.     {   visualizarPorApellido1(cabeza,ape1);
  151.       getchar();
  152.     getchar();
  153.     }
  154.     break;
  155.  
  156.     case 6: visualizarCabezaCola(cabeza);
  157.    
  158.            getchar();
  159.       break;
  160.     case 7: visualizarColaCabeza(cabeza);
  161.            getchar();
  162.      
  163.   case 10: printf(&#34;Introduzca el nombre del fichero: &#34;);
  164.          scanf(&#34;%s&#34;, fichero);
  165.          fflush(stdin);
  166.       grabarLista(cabeza, fichero);
  167.      break;
  168.      
  169.      } //cierre del switch
  170.  
  171.  
  172.    }while (opcion);  /* opcion != 0 */
  173.  }
  174.  
  175. /************************ Función crear() ***************************/
  176. /*
  177.    Propósito..: Crea la lista.
  178.    Parámetros.: Puntero cabeza de lista por referencia.
  179.    Devuelve...: Nada.
  180. */
  181. /********************************************************************/
  182.  
  183. void crearLista(struct lista **cabeza)
  184. {
  185.       *cabeza = NULL;
  186.    
  187. }
  188.  
  189. void cogerDatosTexto(struct lista **cabeza)
  190. {
  191.  
  192.     FILE *p; //declaro un puntero al fichero
  193.     struct lista *actual;
  194.     struct lista *aux;
  195.   char nombre[15];
  196.   char ape1[20];
  197.   char ape2[20];
  198.   int edad = 0;
  199.  
  200.  if((p=fopen(&#34;listas.txt&#34;,&#34;r&#34;)) == NULL) // abro para lectura
  201.  {
  202.    printf(&#34;&#092;n Error al abrir el archivo&#092;n&#34;);
  203.    exit (1);
  204.  }
  205.  
  206.   *cabeza=NULL;
  207.  
  208.     while(fscanf(p,&#34;%s %s %s %d&#34;,nombre,ape1,ape2,&edad)!=EOF)
  209.     {
  210.     //reservamos espacio para el nuevo elemento
  211.     actual = nuevoElemento();
  212.  
  213.      strcpy(actual-&#62;nombre,nombre);
  214.     strcpy(actual-&#62;ape1,ape1);
  215.     strcpy(actual-&#62;ape2,ape2);
  216.     actual-&#62;edad=edad;
  217.     actual-&#62;sig = NULL;
  218.     if(*cabeza ==NULL)
  219.       *cabeza = actual;
  220.     else
  221.       aux-&#62;sig = actual;
  222.  
  223.     fflush(stdin);
  224.     aux = actual;
  225.   }
  226.    fclose(p);
  227.  
  228. }
  229.  
  230.  
  231.  void presentaMenu(void)
  232. {
  233.    printf(&#34;EJEMPLO DE LISTA ENLAZADA&#092;n&#34;);
  234.    printf(&#34;-------------------------&#092;n&#092;n&#34;);
  235.      printf(&#34;1.- Insertar al Principio&#092;n&#34;);
  236.      printf(&#34;2.- Insertar al Final&#092;n&#34;);
  237.      printf(&#34;3.- Insertar por apellido1&#092;n&#34;);
  238.      printf(&#34;4.- Borrar por apellido 1&#092;n&#34;);
  239.      printf(&#34;5.- Visualizar por apellido1 &#092;n&#34;);
  240.      printf(&#34;6.- Visualizar cabeza cola&#092;n&#34;);
  241.      printf(&#34;7.- Visualizar cola cabeza&#092;n&#34;);
  242.      printf(&#34;8.- Liberar Memoria&#092;n&#34;);
  243.      printf(&#34;9.- Liberar Memoria Recursivo&#092;n&#34;);
  244.      printf(&#34;10.- Grabar Lista&#092;n&#34;);
  245.      printf(&#34;0.- TERMINAR.&#092;n&#092;n&#092;n&#34;);
  246. }
  247.    
  248.  /******************************Funcion nuevoElemento****************/
  249. /*Funcion que sirve para reservar espacio para un nuevo elemento*/
  250.  
  251. struct lista* nuevoElemento()
  252. {
  253.     struct lista *a;
  254.     a = (struct lista*)malloc(sizeof(struct lista));
  255.     return a;
  256. }
  257.  
  258.  
  259. /************************ Función vacia() ***************************/
  260. /*
  261.    Propósito:  Comprueba si la lista está vacía.
  262.    Parámetros: Puntero cabeza de lista por valor.
  263.    Devuelve:   1 si la lista está vacía.
  264.                0 si no lo está.
  265. */
  266. /********************************************************************/
  267. int listaVacia(struct lista *cabeza)
  268. {
  269.    if (cabeza==NULL)
  270.       return SI;    /* verdad */
  271.    else
  272.       return NO;    /* falso */
  273. }
  274.  
  275. /*Funcion que sirve para insertar los datos al principio de la lista*/
  276.  
  277. void insertarPrincipio(struct lista **cabeza, char *nombre, char *ape1, char *ape2, int edad)
  278. {
  279.     struct lista *nuevo;
  280.   /*reservamos espacio para el nuevo elemento*/
  281.     nuevo = nuevoElemento();
  282.    
  283.   strcpy(nuevo-&#62;nombre, nombre);
  284.     strcpy(nuevo-&#62;ape1, ape1);
  285.     strcpy(nuevo-&#62;ape2, ape2);
  286.     nuevo-&#62;edad = edad;
  287.    
  288.     nuevo-&#62;sig = *cabeza;
  289.     *cabeza = nuevo;
  290. }
  291.  
  292. //FUNCION BUSCAR PERSONA
  293.  
  294.   struct lista* buscarPersona(struct lista *cabeza, char *ape1)
  295.   {
  296.        
  297.     struct lista *existe;
  298.   existe = cabeza;
  299.  
  300.     if (listaVacia(cabeza) == SI)
  301.     {
  302.       printf(&#34;&#092;n La lista esta vacia.&#092;n&#34;);
  303.      
  304.     }
  305.  
  306.     //se recorre la lista hasta encontar el elemento o hasta llegar al final
  307.     while(existe!=NULL)
  308.     {
  309.         if(strcmp(existe-&#62;ape1, ape1)== 0)
  310.     {  
  311.       return existe;
  312.    
  313.         }  
  314.         else{
  315.            existe= existe-&#62;sig;
  316.     }
  317.   }
  318.   return (NULL);
  319.  
  320. }        
  321.  
  322. //Funcion que sirve para insertar los datos al final de la lista
  323.  
  324. void insertarFinal(struct lista **cabeza, char *nombre, char *ape1, char *ape2, int edad)
  325. {
  326.     struct lista *nuevo = NULL;
  327.     struct lista *aux = NULL;
  328.    
  329.     //se reserva espacio para el nuevo elemento
  330.     nuevo = nuevoElemento();
  331.   strcpy(nuevo-&#62;nombre, nombre);
  332.     strcpy(nuevo-&#62;ape1, ape1);
  333.     strcpy(nuevo-&#62;ape2, ape2);
  334.     nuevo-&#62;edad = edad;
  335.     nuevo-&#62;sig = NULL;
  336.    
  337.     if(listaVacia(*cabeza) == SI) //la lista esta vacia, el nuevo sera la cabeza
  338.         *cabeza = nuevo;
  339.     else //se localiza el ultimo elemento para enlazarlo al nuevo
  340.     {
  341.         aux = *cabeza;
  342.         while(aux-&#62;sig != NULL)
  343.         {
  344.             aux = aux-&#62;sig;
  345.         }
  346.         aux-&#62;sig = nuevo; //cuando recorra la lista aux-&#62;sig apunta a nuevo
  347.    
  348.     }
  349. }
  350.        
  351.  
  352. void introducirDatos(char *nombre, char *ape1, char *ape2, int edad)
  353. {
  354.           printf(&#34;&#092;n Introduzca el nombre =&#62; &#34;);
  355.       gets(nombre);
  356.       fflush(stdin);
  357.    
  358.           printf(&#34;&#092;nIntroduzca el apellido1 =&#62; &#34;);
  359.           gets(ape1);
  360.           fflush(stdin);
  361.        
  362.    
  363.           printf(&#34;&#092;nIntroduzca el apellido2 =&#62; &#34;);
  364.           gets(ape2);
  365.           fflush(stdin);
  366.        
  367.    
  368.           printf(&#34;&#092;nIntroduzca la edad =&#62; &#34;);
  369.           scanf(&#34;%d&#34;,&edad);
  370.           fflush(stdin);
  371.        
  372. }
  373.  
  374. void mostrarLista(struct lista *cabeza)
  375. {
  376.   struct lista *actual;
  377.   actual = cabeza;
  378.  
  379.   while(actual!=NULL)
  380.   {
  381.   printf(&#34;%s %s %s %d &#092;n&#34;,actual-&#62;nombre,actual-&#62;ape1,actual-&#62;ape2,actual-&#62;edad);
  382.   actual = actual-&#62;sig;
  383.   }
  384.   printf(&#34;&#092;n&#34;);
  385.  
  386. }
  387.  
  388. void visualizarNodo(struct lista *nodo)
  389. {
  390.          printf(&#34;&#092;n Nombre.....: %s&#34;
  391.                 &#34;&#092;n Apellido1......: %s&#34;
  392.                 &#34;&#092;n Apellido2.....: %s&#34;
  393.                 &#34;&#092;n Edad.....: %d &#092;n&#34;,nodo-&#62;nombre,nodo-&#62;ape1,nodo-&#62;ape2,nodo-&#62;edad);
  394. }
  395.  
  396. //Esta funcion sirve para insertar por orden alfabetico el primer apellido
  397.  
  398. void insertarPorApellido1(struct lista **cabeza, char *nombre, char *ape1, char *ape2, int edad)
  399. {
  400.    struct lista *aux=NULL; //almacena elemento posterior al que se inserta
  401.    struct lista *ant =NULL; //almacena elemento anterior al que se inserta
  402.    struct lista *nuevo = NULL; //almacena el nuevo elemento
  403.    int encontrado  = 0;
  404.    
  405.    //Se reserva espacio para el nuevo elemento
  406.   nuevo = nuevoElemento();
  407.   strcpy(nuevo-&#62;nombre, nombre);
  408.   strcpy(nuevo-&#62;ape1, ape1);
  409.   strcpy(nuevo-&#62;ape2, ape2);
  410.   nuevo-&#62;edad = edad;
  411.  
  412.    if(listaVacia(*cabeza) == SI) //comprueba si la lista esta vacia
  413.    {
  414.  
  415.   *cabeza = nuevo; //la cabeza será el nuevo elemento
  416.   nuevo-&#62;sig = NULL;
  417.    }
  418.  
  419.    else{
  420.      aux = *cabeza;
  421.      if(strcmp(aux-&#62;ape1, ape1)&#62;0 ) //nuevo elemento se inserta delante de
  422.                                         //la cabeza
  423.        {
  424.         nuevo-&#62;sig=*cabeza; //El siguiente de nuevo será la cabeza
  425.        *cabeza=nuevo;
  426.        }
  427.      else //buscamos la posicion de insercion, se interrumpe cuando se
  428.      //encuentra el primer elemento mayor que n o cuando se llega al final de la lista
  429.          {
  430.  
  431.               while(aux!=NULL && encontrado == 0) {
  432.                    if( strcmp( aux-&#62;ape1, ape1 ) &#62;=0 ) //hemos encontrado la posicion de insercion
  433.                     {
  434.                       encontrado = 1;
  435.                      break;
  436.                    
  437.                      }
  438.                    else //se actualizan los valores de ayx y ant
  439.                        {
  440.                        ant=aux;
  441.                        aux=aux-&#62;sig;
  442.                        }
  443.  
  444.              }
  445.         if(aux == NULL){  //el elemento se inserta al final
  446.                 ant-&#62;sig = nuevo;    
  447.         nuevo-&#62;sig = aux;
  448.         }
  449.    }
  450.    }
  451.  
  452. }
  453.  
  454. void borrarPorApellido1(struct lista **cabeza, char *ape1)
  455. {
  456.  struct lista *ant = NULL; //almacena el elemento anterior al que se borra
  457.  struct lista *borrar;  //almacena el elemento a borrar
  458.  
  459. if (listaVacia(*cabeza) == SI)
  460. {
  461.       printf(&#34;&#092;n La lista esta vacia.&#092;n&#34;);
  462.     exit (0);
  463. }
  464.  
  465. else if (strcmp(ape1, (*cabeza)-&#62;ape1) == 0 ) //el elemento a borrar es cabeza
  466.         {
  467.        borrar = *cabeza;
  468.          *cabeza = (*cabeza)-&#62;sig;
  469.          free(borrar); //se libera la antigua cabeza
  470.         }
  471. else {
  472.   ant = *cabeza;
  473.   borrar = (*cabeza) -&#62; sig;
  474. }
  475.  
  476. while(borrar != NULL)
  477.      {
  478.     if(!strcmp(ape1, borrar-&#62;ape1)) break;
  479.            
  480.       else{ //si son distintos
  481.              ant = borrar;
  482.              borrar = borrar-&#62;sig;
  483.             }
  484.      }
  485.  
  486.  
  487.  //el elemento a borrar no es la cabeza
  488.      if (borrar != NULL)    //Si borrar es distinto de NULL
  489.       {
  490.      //si el elemento a borrar no es la cabeza  
  491.      
  492.             ant-&#62;sig = borrar-&#62;sig;;
  493.            free(borrar);
  494.    }
  495.    
  496.   printf(&#34;&#092;n&#092;n El apellido ha sido borrado&#092;n&#34;);
  497.   fflush(stdin);
  498.   getchar();
  499. }
  500.  
  501. //Visualizar por Apellido1
  502.  
  503.   void visualizarPorApellido1(struct lista *cabeza,char *ape1)
  504.   {
  505.    
  506.     struct lista *aux = NULL;
  507.     aux = cabeza;
  508.     while( aux!= NULL )
  509.        {
  510.        if( strcmp(aux-&#62;ape1, ape1)==0 )
  511.            {
  512.            visualizarNodo(aux);
  513.        aux = aux-&#62;sig;
  514.            }
  515.       else {
  516.            aux=aux-&#62;sig;
  517.        }
  518.    
  519.   }
  520.    
  521. }
  522.  
  523.  
  524. void visualizarCabezaCola(struct lista *cabeza)
  525. {
  526.   if (listaVacia(cabeza) == SI)
  527.  {
  528.    printf(&#34;&#092;n La lista esta vacia&#092;n&#34;);
  529.    
  530.    }
  531.    else{
  532.     printf(&#34;&#092;n Nombre.........: %s&#34;, cabeza-&#62;nombre);
  533.     printf(&#34;&#092;n Apellido1......: %s&#34;, cabeza-&#62;ape1);
  534.     printf(&#34;&#092;n Apellido2......: %s&#34;, cabeza-&#62;ape2);
  535.     printf(&#34;&#092;n Edad...........: %d&#092;n&#34;, cabeza-&#62;edad);
  536.          
  537.     //visualizaCabezaCola(cabeza-&#62;sig);
  538.   getchar();
  539.   fflush(stdin);
  540.  
  541.     }
  542. }
  543.  
  544. void visualizarColaCabeza(struct lista *cabeza)
  545. {
  546.   if (listaVacia(cabeza) == SI)
  547.  {
  548.    printf(&#34;&#092;n La lista esta vacia&#092;n&#34;);
  549.    
  550.    }
  551.    else{
  552.     visualizarColaCabeza(cabeza-&#62;sig);
  553.   printf(&#34;&#092;n Nombre.........: %s&#34;, cabeza-&#62; nombre);
  554.     printf(&#34;&#092;n Apellido1......: %s&#34;, cabeza-&#62;ape1);
  555.     printf(&#34;&#092;n Apellido2......: %s&#34; ,cabeza-&#62;ape2);
  556.     printf(&#34;&#092;n Edad...........: %d&#092;n&#34;, cabeza-&#62;edad);
  557.     getchar();
  558.   fflush(stdin);
  559.  
  560.    
  561.     }
  562.    }
  563.  
  564. //grabar lista
  565.  
  566. void grabarLista(struct lista *cabeza, char *fichero)
  567. {
  568.   FILE *f;
  569.   struct lista *actual = cabeza;
  570.  
  571.  
  572.   if (listaVacia(cabeza) ==SI)
  573.   {
  574.    printf(&#34;&#092;n La lista esta vacia&#092;n&#34;);
  575.    
  576.   }
  577.  
  578.   f=fopen(fichero, &#34;wb&#34;);
  579.  
  580.     while(actual!=NULL){
  581.      
  582.           fwrite(actual, sizeof(struct lista), 1, f);
  583.          actual = actual-&#62;sig;
  584.      }
  585.    fclose(f);
  586.  
  587.    
  588.  }
  589.  
  590. /*listas.h*/
  591. /*Declaracion de estructuras y funciones*/
  592.  
  593. #include &#60;stdio.h&#62;
  594. #include &#60;stdlib.h&#62;
  595. #include &#60;string.h&#62;
  596. #include &#60;malloc.h&#62;
  597. #define SI 1
  598. #define NO 0
  599.  
  600. struct lista
  601. {
  602.     char nombre[15];
  603.     char ape1[20];
  604.     char ape2[20];
  605.     int edad;
  606.     struct lista *sig;
  607. };
  608. struct lista *nuevo;
  609.  
  610. void cogerDatosTexto(struct lista **cabeza);
  611.  
  612. void introducirDatos(char *nombre, char *ape1, char *ape2, int edad);
  613.  
  614. struct lista* nuevoElemento();
  615. void presentaMenu(void);
  616. void crearLista(struct lista **cabeza);
  617. int listaVacia(struct lista *cabeza);
  618. void insertarPrincipio(struct lista **cabeza, char *nombre, char *ape1, char *ape2, int edad);
  619. void visualizarNodo(struct lista *nodo);
  620.  
  621. void mostrarLista(struct lista *cabeza);
  622. void insertarFinal(struct lista **cabeza, char *nombre, char *ape1, char *ape2, int edad);
  623. void insertarPorApellido1(struct lista **cabeza, char *nombre, char *ape1, char *ape2, int edad);
  624.  
  625. void visualizarPorApellido1(struct lista *cabeza,char *ape1);
  626. struct lista* buscarPersona(struct lista *cabeza, char *ape1);
  627. void visualizarCabezaCola(struct lista *cabeza);
  628. void visualizarColaCabeza(struct lista *cabeza);
  629. void liberarMemoria(struct lista **cabeza);
  630. void liberarMemoriaRecursivo(struct lista **cabeza);
  631. void grabarLista(struct lista *cabeza, char *fichero);
  632. void borrarPorApellido1(struct lista **cabeza, char *ape1);
  633.  
  634.  
  635.  


Yo de momento, lo que veo q aunque funcionen bien las de insertarPrincipio, y insertarFinal, la lista sale, pero luego da error de ejecución de memoria.
Luego en inserttarApellido1, no sé si es que tengo que hcer alguna funcion de ordenar lista, porque si no, no tiene sentido, y la de borrar Apellido1, no me sale bien la ejecucion, lo pide, pero no lo borra, da errores luego al mostrar la lista.
Gracias.

42
C/C++ / Re: Error De Ejecución En Memoria
« en: Viernes 10 de Diciembre de 2004, 20:46 »
Cita de: "JuanK"
hola, creo que habia un nuevo mensaje tuyo pero se borro por los problemas del lunes, podrias volverlo a postear por favor?
Hola Juank, he visto tu mensaje, y te digo que por favor, si puedes ayudarme leas de nuevo lo que he colgado en el foro, necesito ayuda para dos de las funciones, asi que solo he puesto el codigo necesario,para las mismas.De todos modos, si tienes interes en ayudarme, te daré mi correo. Es que esto es muy importante, tengo examen el lunes, y me juego la nota.
gRACIAS
 :hola:

43
C/C++ / Error De Ejecución En Memoria
« en: Lunes 6 de Diciembre de 2004, 20:05 »
Hola a todos, estoy desesperada, tengo que ahcer una practica de listas, y he optado por ir haciendo poco a poco, función a función, resulta que me compila, pero me da un error de ejecución en memoria, en las funciones InsertarporApellido1 y borrarporApellido1, asi que voy a a poner el enunciado de la práctica, y el código que yo he hecho, por si alguien puede ayudarme, gracias.Solo he puesto el codigo necesario para que funcionen estas funciones.

El codigo es este: adjunto el de listas. h y listas. C
Código: Text
  1.  
  2. #include &#34;listas.h&#34;
  3.  
  4. /* Programa principal */
  5. main()
  6. {
  7.  struct lista *existe;
  8.  struct lista *cabeza;
  9.  char nombre[15];
  10.  char ape1[20];
  11.  char ape2[20];
  12.  int edad = 0;
  13.  int opcion;
  14.  char resp;
  15.  
  16.   /* opciones */
  17. do{
  18.   
  19.  crearLista(&cabeza);
  20.      
  21.     
  22.   do{
  23.       cogerDatosTexto(&cabeza);
  24.       printf(&#34;&#092;n La lista enlazada es asi: &#092;n&#092;n&#34;);
  25.     mostrarLista(cabeza);  
  26.     presentaMenu();
  27.     printf(&#34;Introduce una opcion: &#34;);
  28.      scanf(&#34;%d&#34;,&opcion);
  29.      fflush(stdin);
  30.   
  31.     
  32.  }while(opcion &#60;0 || opcion &#62; 11);
  33.       
  34.   
  35.  
  36.       switch(opcion)
  37.       {
  38.   
  39.       
  40.      case 3: /*Insertar por apellido1*/
  41.         introducirDatos(nombre, ape1, ape2, edad);  
  42.         /*comprobamos si existe la persona*/
  43.               existe = buscarPersona(cabeza, ape1);
  44.       
  45.       if(!existe)
  46.       {
  47.             do
  48.            {
  49.             insertarPorApellido1(&cabeza, nombre, ape1, ape2, edad);            printf(&#34;&#092;n&#092;n¿Desea introducir otra persona? (S/N): &#34;);
  50.             scanf(&#34;%c&#34;, &resp);
  51.             system(&#34;clear&#34;);
  52.            }while(resp == 's' || resp =='S');
  53.        mostrarLista(cabeza);
  54.        getchar();
  55.     }
  56.          
  57.     else
  58.        printf(&#34;&#092;n Esta persona ya existe&#34;);
  59.          visualizarNodo(existe);
  60.            getchar();
  61.            getchar();
  62.     
  63.       break;
  64.  
  65.      case 4: /*Borrar por apellido1*/
  66.          printf(&#34;&#092;n Introduzca el apellido a borrar: &#34;);
  67.          gets(ape1);
  68.         
  69.      //comprobamos si la persona existe
  70.         existe = buscarPersona(cabeza, ape1);
  71.  
  72.        if(existe) //si existe
  73.        {
  74.           borrarPorApellido1(&cabeza, ape1);
  75.         printf(&#34;&#092;n Elemento borrado&#34;);
  76.          mostrarLista(cabeza);
  77.        }    
  78.       else
  79.        printf(&#34;&#092;n Elemento no encontrado&#092;n&#34;);
  80.  
  81.      getchar();
  82.      getchar();
  83.      break;
  84.     
  85.   
  86.   
  87.       } //cierre del switch
  88.    }while (opcion);  /* opcion != 0 */
  89.  }
  90.  
  91. /************************ Función crear() ***************************/
  92. /*
  93.    Propósito..: Crea la lista.
  94.    Parámetros.: Puntero cabeza de lista por referencia.
  95.    Devuelve...: Nada.
  96. */
  97. /********************************************************************/
  98.  
  99. void crearLista(struct lista **cabeza)
  100. {
  101.       *cabeza = NULL;
  102.     
  103. }
  104.  
  105.  void presentaMenu(void)
  106. {
  107.    printf(&#34;EJEMPLO DE LISTA ENLAZADA&#092;n&#34;);
  108.    printf(&#34;-------------------------&#092;n&#092;n&#34;);
  109.      printf(&#34;1.- Insertar al Principio&#092;n&#34;);
  110.      printf(&#34;2.- Insertar al Final&#092;n&#34;);
  111.      printf(&#34;3.- Insertar por apellido1&#092;n&#34;);
  112.      printf(&#34;4.- Borrar por apellido 1&#092;n&#34;);
  113.      printf(&#34;5.- Visualizar por apellido1 &#092;n&#34;);
  114.      printf(&#34;6.- Visualizar cabeza cola&#092;n&#34;);
  115.      printf(&#34;7.- Visualizar cola cabeza&#092;n&#34;);
  116.      printf(&#34;8.- Liberar Memoria&#092;n&#34;);
  117.      printf(&#34;9.- Liberar Memoria Recursivo&#092;n&#34;);
  118.      printf(&#34;10.- Grabar Lista&#092;n&#34;);
  119.      printf(&#34;0.- TERMINAR.&#092;n&#092;n&#092;n&#34;);
  120. }
  121.     
  122.  /******************************Funcion nuevoElemento****************/
  123. /*Funcion que sirve para reservar espacio para un nuevo elemento*/
  124.  
  125. struct lista* nuevoElemento()
  126. {
  127.     struct lista *a;
  128.     a = (struct lista*)malloc(sizeof(struct lista));
  129.     return a;
  130. }
  131.  
  132.  
  133. /************************ Función vacia() ***************************/
  134. /*
  135.    Propósito:  Comprueba si la lista está vacía.
  136.    Parámetros: Puntero cabeza de lista por valor.
  137.    Devuelve:   1 si la lista está vacía.
  138.                0 si no lo está.
  139. */
  140. /********************************************************************/
  141. int listaVacia(struct lista *cabeza)
  142. {
  143.    if (cabeza==NULL)
  144.       return SI;    /* verdad */
  145.    else
  146.       return NO;    /* falso */
  147. }
  148.  
  149.  
  150. //FUNCION BUSCAR PERSONA
  151.  
  152.   struct lista* buscarPersona(struct lista *cabeza, char *ape1)
  153.   {
  154.         
  155.     struct lista *existe;
  156.   existe = cabeza;
  157.  
  158.     if (listaVacia(cabeza) == SI)
  159.     {
  160.       printf(&#34;&#092;n La lista esta vacia.&#092;n&#34;);
  161.       
  162.     }
  163.  
  164.     //se recorre la lista hasta encontar el elemento o hasta llegar al final
  165.     while(existe!=NULL)
  166.     {
  167.         if(strcmp(existe-&#62;ape1, ape1)== 0)
  168.     {  
  169.       return existe;
  170.     
  171.         }  
  172.         else{
  173.            existe= existe-&#62;sig;
  174.     }
  175.   }
  176.   return (NULL);
  177.  
  178. }        
  179.  
  180. void introducirDatos(char *nombre, char *ape1, char *ape2, int edad)
  181. {
  182.           printf(&#34;&#092;n Introduzca el nombre =&#62; &#34;);
  183.       gets(nombre);
  184.       fflush(stdin);
  185.   
  186.           printf(&#34;&#092;nIntroduzca el apellido1 =&#62; &#34;);
  187.           gets(ape1);
  188.           fflush(stdin);
  189.         
  190.   
  191.           printf(&#34;&#092;nIntroduzca el apellido2 =&#62; &#34;);
  192.           gets(ape2);
  193.           fflush(stdin);
  194.         
  195.   
  196.           printf(&#34;&#092;nIntroduzca la edad =&#62; &#34;);
  197.           scanf(&#34;%d&#34;,&edad);
  198.           fflush(stdin);
  199.         
  200. }
  201.  
  202. void mostrarLista(struct lista *cabeza)
  203. {
  204.   struct lista *actual;
  205.   actual = cabeza;
  206.  
  207.   while(actual!=NULL)
  208.   {
  209.   printf(&#34;%s %s %s %d &#092;n&#34;,actual-&#62;nombre,actual-&#62;ape1,actual-&#62;ape2,actual-&#62;edad);
  210.   actual = actual-&#62;sig;
  211.   }
  212.   printf(&#34;&#092;n&#34;);
  213.   
  214. }
  215.  
  216. void visualizarNodo(struct lista *nodo)
  217. {
  218.          printf(&#34;&#092;n Nombre.....: %s&#34;
  219.                 &#34;&#092;n Apellido1......: %s&#34;
  220.                 &#34;&#092;n Apellido2.....: %s&#34;
  221.                 &#34;&#092;n Edad.....: %d &#092;n&#34;,nodo-&#62;nombre,nodo-&#62;ape1,nodo-&#62;ape2,nodo-&#62;edad);
  222. }
  223.  
  224. //Esta funcion sirve para insertar por orden alfabetico el primer apellido
  225.  
  226. void insertarPorApellido1(struct lista **cabeza, char *nombre, char *ape1, char *ape2, int edad)
  227. {
  228.    struct lista *aux=NULL; //almacena elemento posterior al que se inserta
  229.    struct lista *ant =NULL; //almacena elemento anterior al que se inserta
  230.    struct lista *nuevo = NULL; //almacena el nuevo elemento
  231.    int encontrado  = 0;
  232.   
  233.    //Se reserva espacio para el nuevo elemento
  234.   nuevo = nuevoElemento();
  235.   strcpy(nuevo-&#62;nombre, nombre);
  236.   strcpy(nuevo-&#62;ape1, ape1);
  237.   strcpy(nuevo-&#62;ape2, ape2);
  238.   nuevo-&#62;edad = edad;
  239.  
  240.    if(listaVacia(*cabeza) == SI) //comprueba si la lista esta vacia
  241.    {
  242.   
  243.   *cabeza = nuevo; //la cabeza será el nuevo elemento
  244.   nuevo-&#62;sig = NULL;
  245.    }
  246.  
  247.    else{
  248.      aux = *cabeza;
  249.      if(strcmp(aux-&#62;ape1, ape1)&#62;0 ) //nuevo elemento se inserta delante de
  250.                                         //la cabeza
  251.        {
  252.         nuevo-&#62;sig=*cabeza; //El siguiente de nuevo será la cabeza
  253.        *cabeza=nuevo;
  254.        }
  255.      else //buscamos la posicion de insercion, se interrumpe cuando se
  256.      //encuentra el primer elemento mayor que n o cuando se llega al final de la lista
  257.          {
  258.   
  259.               while(aux!=NULL && encontrado == 0) {
  260.                    if( strcmp( aux-&#62;ape1, ape1 ) &#62;=0 ) //hemos encontrado la posicion de insercion
  261.                     {
  262.                       encontrado = 1;
  263.                      break;
  264.                     
  265.                      }
  266.                    else //se actualizan los valores de ayx y ant
  267.                        {
  268.                        ant=aux;
  269.                        aux=aux-&#62;sig;
  270.                        }
  271.  
  272.              }
  273.         if(aux == NULL){  //el elemento se inserta al final
  274.                 ant-&#62;sig = nuevo;    
  275.         nuevo-&#62;sig = aux;
  276.         }
  277.    }
  278.    }
  279.  
  280. }
  281.  
  282. void borrarPorApellido1(struct lista **cabeza, char *ape1)
  283. {
  284.  struct lista *ant = NULL; //almacena el elemento anterior al que se borra
  285.  struct lista *borrar;  //almacena el elemento a borrar
  286.  borrar = *cabeza;
  287.  
  288. if (listaVacia(*cabeza) == SI)
  289. {
  290.       printf(&#34;&#092;n La lista esta vacia.&#092;n&#34;);
  291.     exit (0);
  292. }
  293.  
  294. while(borrar != NULL)
  295.      {
  296.     if(!strcmp(ape1, borrar-&#62;ape1)) break;
  297.             
  298.       else{ //si son distintos
  299.              ant = borrar;
  300.              borrar = borrar-&#62;sig;
  301.             }
  302.      }
  303.   
  304. if (strcmp(ape1, (*cabeza)-&#62;ape1) == 0 ) //el elemento a borrar es cabeza
  305.         {
  306.          *cabeza = borrar-&#62;sig;
  307.          free(borrar); //se libera la antigua cabeza
  308.         }
  309.   
  310.       //el elemento a borrar no es la cabeza
  311.      if (borrar != NULL)    //Si borrar es distinto de NULL
  312.       {
  313.      if(borrar == *cabeza)
  314.      {
  315.        *cabeza = borrar-&#62;sig;
  316.        free(borrar);
  317.      }
  318.       else //si el elemento a borrar no es la cabeza  
  319.       {
  320.             ant-&#62;sig = borrar-&#62;sig;;
  321.            free(borrar);
  322.       }
  323.    }
  324.       printf(&#34;&#092;n&#092;n El apellido ha sido borrado&#092;n&#34;);
  325.          fflush(stdin);
  326.          getchar();
  327. }
  328.  
  329. /*listas.h*/
  330. /*Declaracion de estructuras y funciones*/
  331.  
  332. #include &#60;stdio.h&#62;
  333. #include &#60;stdlib.h&#62;
  334. #include &#60;string.h&#62;
  335. #include &#60;malloc.h&#62;
  336. #define SI 1
  337. #define NO 0
  338.  
  339. struct lista
  340. {
  341.     char nombre[15];
  342.     char ape1[15];
  343.     char ape2[15];
  344.     int edad;
  345.     struct lista *sig;
  346. };
  347. struct lista *nuevo;
  348.  
  349. void cogerDatosTexto(struct lista **cabeza);
  350.  
  351. void introducirDatos(char *nombre, char *ape1, char *ape2, int edad);
  352.  
  353. struct lista* nuevoElemento();
  354. void presentaMenu(void);
  355. void crearLista(struct lista **cabeza);
  356. int listaVacia(struct lista *cabeza);
  357. void insertarPrincipio(struct lista **cabeza, char *nombre, char *ape1, char *ape2, int edad);
  358. void visualizarNodo(struct lista *nodo);
  359.  
  360. void mostrarLista(struct lista *cabeza);
  361. void insertarFinal(struct lista **cabeza, char *nombre, char *ape1, char *ape2, int edad);
  362. void insertarPorApellido1(struct lista **cabeza, char *nombre, char *ape1, char *ape2, int edad);
  363.  
  364.  
  365. visualizarpersona(struct lista *cabeza, char *nombre);
  366. void visualizarPorApellido1(struct lista *cabeza,char *ape1);
  367. struct lista* buscarPersona(struct lista *cabeza, char *ape1);
  368. void visualizarCabezaCola(struct lista *cabeza);
  369. void visualizarColaCabeza(struct lista *cabeza);
  370. void liberarMemoria(struct lista **cabeza);
  371. void liberarMemoriaRecursivo(struct lista **cabeza);
  372. void grabarLista(struct lista *cabeza, char *fichero);
  373. void borrarPorApellido1(struct lista **cabeza, char *ape1);
  374.  
  375.  

Gracias a todos,  :)
Si Juank, ve esto, que sepa q solo me refiero a la funcion borrarPorApellido1

44
C/C++ / Re: Duda De Listas Simples En C
« en: Sábado 4 de Diciembre de 2004, 18:09 »
Cita de: "Diodo"
Hola ¡¡¡  :hola:  Cuanto tiempo ¡¡   :D

Pues si parece que estuvo bastante tiempo sin funcionar esto, yo intente entrar varios dias seguidos pero me canse y deje de intentarlo xd. Desde cuando esta esto operativo?

Espero que hayas progresado algo en la practica, yo hice algo pero como no tenia donde mandartelo (por cierto que con tu permiso te agrego al messenger, que siempre viene bien tener una informatica a mano jeje)
Creo que consigo meter lo del archivo de texto en la lista pero al mostrarlo por pantalla solo me sale el ultimo registro, a  lo mejor es que esta mal la funcion de mostrar, echale tu un vistazo a ver si das con el fallo. De todas maneras este puente que tengo mas tiempo libre lo mirare de nuevo que ya ni me acuerdo lo que hice.

fwrite es para grabar los registros en un archivo .DAT asi que no te sirve para meter nada en las listas, para meterlos en una lista tendras que crear tu la funcion ir leyendo del archivo de texto y meter cada registro en un nodo de la lista

Este es el codigo que hice:

Código: Text
  1.  
  2. #include &#60;stdio.h&#62;
  3. #include &#60;stdlib.h&#62;
  4. #include &#60;string.h&#62;
  5.  
  6. struct lista
  7. {
  8.   char nombre[15];
  9.   char ape1[15];
  10.   char ape2[15];
  11.   int edad;
  12.   struct lista *enlace;
  13. };
  14.  
  15. typedef struct lista LISTA;
  16.  
  17. int menu(void);
  18. void cogerDatosTexto(LISTA *ptr);
  19. void mostrarLista(LISTA *ptr);
  20.  
  21.  
  22. void main()
  23. {
  24.  
  25.   LISTA *principal;
  26.   int eleccion;
  27.   do
  28.   {
  29.        eleccion =menu();
  30.        switch (eleccion)
  31.         {
  32.           case 1:
  33.             principal= (LISTA *) malloc(sizeof(LISTA));
  34.             cogerDatosTexto(principal);  
  35.             continue;  
  36.  
  37.          case 2:
  38.            printf(&#34;&#092;n&#34;);
  39.            mostrarLista(principal);
  40.            continue;
  41.  
  42.          default:
  43.            printf(&#34;fin de las operaciones&#092;n&#34;);
  44.        }  
  45.     }while(eleccion !=3);
  46. }
  47.  
  48.  
  49.  
  50. int menu(void)
  51.  {
  52.    int eleccion;
  53.    do
  54.      {
  55.        printf(&#34;&#092;n menu principal:&#092;n&#34;);
  56.        printf(&#34;1.-crear la lista enlazada&#092;n&#34;);
  57.        printf(&#34;2.-mostrar lista&#092;n&#34;);
  58.        printf(&#34;3.-fin&#092;n&#34;);
  59.        printf(&#34;por favor introduzca su elecci¢n (1,2,3)-&#62;&#092;n&#34;);
  60.        scanf(&#34;%d&#34;,&eleccion);
  61.        if (eleccion&#60;1 || eleccion&#62;3)
  62.        printf(&#34;&#092;n ERROR - porfavor , intentelo de nuevo &#092;n&#34;);
  63.      } while(eleccion&#60;1 || eleccion&#62;3);
  64.  
  65.    printf(&#34;&#092;n&#34;);
  66.    return(eleccion);
  67.  }
  68.  
  69. void cogerDatosTexto(LISTA *ptr)
  70. {
  71.   char nom[15];
  72.   char ap1[15];
  73.   char ap2[15];
  74.   int ed;
  75.   FILE *puntero;
  76.  
  77.   puntero=fopen(&#34;TEXTO.TXT&#34;,&#34;r&#34;);
  78.  
  79.   while(fscanf(puntero,&#34;%s %s %s %i&#34;,nom,ap1,ap2,&ed)!=EOF)
  80.   {
  81.     strcpy(ptr-&#62;nombre,nom);
  82.     strcpy(ptr-&#62;ape1,ap1);
  83.     strcpy(ptr-&#62;ape2,ap2);
  84.     ptr-&#62;edad=ed;
  85.     ptr-&#62;enlace=(LISTA*)malloc(sizeof(LISTA));
  86.     fflush(stdin);
  87.   }
  88.   ptr-&#62;enlace=NULL;
  89.  
  90.   fclose(puntero);
  91.  
  92.  
  93. }
  94.  
  95. void mostrarLista(LISTA *ptr)
  96. {
  97.   if(ptr!=NULL)
  98.   {
  99.     printf(&#34;%s %s %s %i &#092;n&#34;,ptr-&#62;nombre,ptr-&#62;ape1,ptr-&#62;ape2,ptr-&#62;edad);
  100.     
  101.  
  102.   }
  103.   return;
  104.  
  105. }
  106.  
  107.  

Para que funcione tienes que crear el archivo de texto TEXTO.txt en el directorio raiz, que si no da error

Espero que te sirva de ayuda, si logro que funcione del todo te aviso

Un saludito  :hola:
Gracias Diodo yo tambien me alegro de tener noticias tuyas, si que creo que tienes razón para lo de grabar lista, asi que voy a probar lo que me has escrito, Ojalá consigamos que funcione bien la practica, jejej.
Gracias de nuevo, saludos.

45
C/C++ / Re: Duda De Listas Simples En C
« en: Lunes 29 de Noviembre de 2004, 19:01 »
Cita de: "i82maria"
Cita de: "Diodo"
Hola  :hola:  Aqui estoy ¡¡  :comp:

Empecemos, ....., lo de texto o binario solamente has de preocuparte a la hora de grabar o cargar archivos, es decir, segun lo que te piden debes cargarlo de uno de texto y grabarlo en uno binario.
fwrite y fread creo que era para el caso de guardar o cargar estructuras enteras en un archivo, el caso que te piden yo creo que es el de un archivo de texto en el que cada dato esta separado por un espacio y cada registro por un salto de linea

ejemplo

Jose Hernando Gutierrez 45
Alfonso Hurtado Sanchez 22
...........
etc

Para poder extraer los datos del archivo de texto he usado fprintf, aqui tienes el codigo, solo me ha dado tiempo a cogerlos e imprimirlos por pantalla, pero seria facil de meter en la lista, mañana nos miramos eso

Código: Text
  1.  
  2.  
  3. #include &#60;stdio.h&#62;
  4.  
  5.  
  6. void main(void)
  7. {
  8.  
  9. // variables para meter temporalmente los datos que leemos del fichero
  10.  
  11. char nombre[15];
  12. char ape1[15];
  13. char ape2[15];
  14. int edad;
  15.  
  16. FILE *puntero; // declaro un puntero al fichero
  17. puntero=fopen(&#34;TEXTO.TXT&#34;,&#34;r&#34;); // asocio ese puntero al archivo y le
  18.                                                  // digo que lo voy a leer
  19.  
  20. /* ahora hacemos un bucle para ir recogiendo cada linea(cada registro) con la funcion fscanf, lo que hace fscanf es leer datos segun le indica el entrecomillado y los mete en las variables que le digamos, cuando acaba con el entrecomillado salta a la siguiente linea.El bucle terminara si se llega al final del archivo EOF*/
  21.  
  22. while(fscanf(puntero,&#34;%s %s %s %i&#34;,nombre,ape1,ape2,&edad)!=EOF)
  23. {
  24. printf(&#34;%s %s %s %i&#092;n&#34;,nombre,ape1,ape2,edad);
  25. }
  26. fclose(puntero); // cerramos el acceso al archivo
  27. printf(&#34;&#092;n&#092;npulsa cualquier tecla para salir&#34;);
  28. getchar();
  29.  
  30. }
  31.  
  32.  

Este es todo el codigo, como puedes ver facilillo,bueno habria que hacerle una implementacion de gestion de errores, ya que por ejemplo si no existe el archivo de texto salta un error de ejecucion

Mañana estare un poco liado que tengo practicas , pero si me da tiempo miro como meterlo en una lista enlazada, aunque eso creo que tu lo dominas bastante mejor  :)

Aqui te dejo el ejecutable para que veas que funciona, puedes probar a cambiar el archivo de texto, pero respetando el orden de los datos

Un saludito  :hola:  animo que esto marcha ¡¡¡  :lol:
Gracias, insisto que eres muy amable, lo de meterlos en la lista, creo que es con fwrite( LISTA, sizeof(struct lista), 1, fp);

No estoy segura pero creo que es así, cuando terminemos esta parte, ya podemos ver si funcionan las funciones no?. Es que eso me preocupa mucho. De nuevo gracias, y te deseo mucha suerte en tus estudios y practicas.
Un saludo Mjose
Hola DIodo, no sabes cuanto me alegro de poder escribirte, resulta que ha estado este foro caido, unas semanas creo, si quieres te dejo mi correo, por si vuelve a caerse el foro, es matrigca@hotmail.com, es que como nos iba tan bien terminando la practica de listas. Asi será mejor. De nuevo, gracias, espero q me contestes pronto, saludos  :hola:

46
C/C++ / Re: Duda De Listas Simples En C
« en: Jueves 18 de Noviembre de 2004, 12:26 »
Cita de: "Diodo"
Hola  :hola:  Aqui estoy ¡¡  :comp:

Empecemos, ....., lo de texto o binario solamente has de preocuparte a la hora de grabar o cargar archivos, es decir, segun lo que te piden debes cargarlo de uno de texto y grabarlo en uno binario.
fwrite y fread creo que era para el caso de guardar o cargar estructuras enteras en un archivo, el caso que te piden yo creo que es el de un archivo de texto en el que cada dato esta separado por un espacio y cada registro por un salto de linea

ejemplo

Jose Hernando Gutierrez 45
Alfonso Hurtado Sanchez 22
...........
etc

Para poder extraer los datos del archivo de texto he usado fprintf, aqui tienes el codigo, solo me ha dado tiempo a cogerlos e imprimirlos por pantalla, pero seria facil de meter en la lista, mañana nos miramos eso

Código: Text
  1.  
  2.  
  3. #include &#60;stdio.h&#62;
  4.  
  5.  
  6. void main(void)
  7. {
  8.  
  9. // variables para meter temporalmente los datos que leemos del fichero
  10.  
  11. char nombre[15];
  12. char ape1[15];
  13. char ape2[15];
  14. int edad;
  15.  
  16. FILE *puntero; // declaro un puntero al fichero
  17. puntero=fopen(&#34;TEXTO.TXT&#34;,&#34;r&#34;); // asocio ese puntero al archivo y le
  18.                                                  // digo que lo voy a leer
  19.  
  20. /* ahora hacemos un bucle para ir recogiendo cada linea(cada registro) con la funcion fscanf, lo que hace fscanf es leer datos segun le indica el entrecomillado y los mete en las variables que le digamos, cuando acaba con el entrecomillado salta a la siguiente linea.El bucle terminara si se llega al final del archivo EOF*/
  21.  
  22. while(fscanf(puntero,&#34;%s %s %s %i&#34;,nombre,ape1,ape2,&edad)!=EOF)
  23. {
  24. printf(&#34;%s %s %s %i&#092;n&#34;,nombre,ape1,ape2,edad);
  25. }
  26. fclose(puntero); // cerramos el acceso al archivo
  27. printf(&#34;&#092;n&#092;npulsa cualquier tecla para salir&#34;);
  28. getchar();
  29.  
  30. }
  31.  
  32.  

Este es todo el codigo, como puedes ver facilillo,bueno habria que hacerle una implementacion de gestion de errores, ya que por ejemplo si no existe el archivo de texto salta un error de ejecucion

Mañana estare un poco liado que tengo practicas , pero si me da tiempo miro como meterlo en una lista enlazada, aunque eso creo que tu lo dominas bastante mejor  :)

Aqui te dejo el ejecutable para que veas que funciona, puedes probar a cambiar el archivo de texto, pero respetando el orden de los datos

Un saludito  :hola:  animo que esto marcha ¡¡¡  :lol:
Gracias, insisto que eres muy amable, lo de meterlos en la lista, creo que es con fwrite( LISTA, sizeof(struct lista), 1, fp);

No estoy segura pero creo que es así, cuando terminemos esta parte, ya podemos ver si funcionan las funciones no?. Es que eso me preocupa mucho. De nuevo gracias, y te deseo mucha suerte en tus estudios y practicas.
Un saludo Mjose

47
ADA / Re: Alguien Sabe Algo De Pvm
« en: Martes 16 de Noviembre de 2004, 12:24 »
Cita de: "Nagisa"
Uhm... Por que no buscas en Google??  :blink: Yo lo he buscado tal cual ("pvm") y me han salido mas de 5.000 resultados en Español. :lol:
Gracias por la molestia, pero eso ya lo he hecho, yo necesito alguien que sepa ese lenguaje, para orientarme de que puedo hacer la practica. Entiendes?. Lo de buscar en el google, ya lo hice. De todos modos, gracias.

48
C/C++ / Re: Duda De Listas Simples En C
« en: Martes 16 de Noviembre de 2004, 12:21 »
Cita de: "Diodo"
Hola ¡¡  :hola:

Citar

Por favor, ya lei lo que me pusiste, me puedes echar una mano, es que no se por dodne empezar, entonces que tengo que quitar todas las funciones, no están bien, además de estar mal porque falta la funcion grabar lista, el resto del codigo, esta mal. Por favor, ayudame, que estoy muy apurada. Gracias
Saludos


 :o

Tranquilidad ¡¡ ante todo tranquilidad, no te pongas nerviosa que es lo peor que puedes hacer,las cosas poco a poco acaban saliendo, y si no a golpes  :lightsabre:  jeje a veces tambien salen

Voy a intentar echarte una mano (con el trabajo  :lol:  no pienses mal ehh  :whistling: ) , pero ten en cuenta que yo tambien estudio  :smartass:  (poco pero estudio) y no dispongo de mucho tiempo libre.

Bueno, lo primero de todo es empezar por el principio,  :blink:  vaya chorradas que digo, queria decir que lo primero de todo seria recuperar los datos del archivo de texto e introducirlos en la lista.Supongo que tendras que usar fopen.......fclose, etc si no es asi dime que librerias usas para manejar archivos.De momento supongo que lo haces con la de stdlib.h (creo que era esa donde estaban), ahi o en stdio.h. Una vez hecho esto hay que implementar las funciones de manejo de la lista

Mañana en el metro me leere todo el lio de manejo de archivos para refrescar la memoria, porque ultimamente solo he usado librerias MFC y las cosas se van olvidando. De todas maneras si quieres ir mirando algun libro te recomiendo el de James L.Antonakos "Programacion estructurada en C" que viene muy bien el tema de archivos y tambien viene el tema de listas enlazadas.Si no puedes conseguirlo dejame un email donde mandarte scaneado esos dos temas.

Mañana por la tarde o el miercoles ya te digo si se me ocurrio algo

Un saludito  :hola: y no te rindas  :comp:
Ante todo lo primero muchisimas gracias, eres un encanto, Me hago cargo de que tambien eres estudiante, y no tienes mucho tiempo. Asi que si alguna vez yo te puedo ayudar en algo, es un placer, porque te estás portando muy bien conmigo.
Según lo dicho, lo primero es crear un fichero de texto, por ejemplo listas. txt. No?
Y dices que hay que abrirlo y meterlo en la lista, verdad?.
Pues yo creo que sería algo así

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>

/*Declaramos la lista*/
struct lista
{
    char nombre[15];
    char ape1[15];
    char ape2[15];
    int edad;
    struct lista *sig;
};

struct lista LISTA;
FILE *fp;
if(fp = fopen("listas.txt", "rb")) == NULL) //abrimos el fichero para lectura{
   printf("Error al abrir el archivo"\n");
 return 0;

else{
       fwrite( LISTA, sizeof(struct lista), 1, fp);
}

Yo creo que es algo asi, primero abro el archivo de texto, listas.txt, auqnue es que pasa una cosa, lo he abierto como binario, para luego poder escribir los datos en la lista, de manera binaria, con el fwrite, que es la forma mejor de pasar toda la estructura entera. Cuando tengas tiempo le echas un vistacillo. Vale?.
Pero apesar de eso, mi mayor preocupación, es saber si el resto de funciones de la lista, estan correctas o no. De nuevo, muchas gracia, me has tranquilizado mucho.
Suerte en tus estudios.
Saludos Mjose

 :hola:

49
C/C++ / Re: Duda De Listas Simples En C
« en: Lunes 15 de Noviembre de 2004, 18:12 »
Cita de: "Diodo"
Hola Maria  :hola:

Lo siento pero creo que no has leido bien el enunciado de la practica  :(  

Realiza un programa en C para gestionar los datos incluidos en un fichero de tipo texto mediante una lista simplemente enlazada.

por eso no te cuadra el apartado 11

11. grabarLista: graba los datos de la lista en un fichero binario. El nombre del fichero debe ser tomado del argumento en la línea de comandos. La función tendrá como parámetros la lista y el nombre del fichero.

En mi opinion lo que tienes que hacer es un programa que lea los datos de un archivo de texto "fichero.txt o fichero.dat" que esta en el disco duro de tu ordenador, entonces carga esos datos a una lista para poder operar con ellos, buscar por apellido, borrar registros, etc y finalmente si el usuario quiere ,volver a grabar los datos en un nuevo archivo, y asi los datos no se pierdan al finalizar la aplicacion

Sera mejor que preguntes a quien te haya mandado hacer la practica , si es eso lo que te pedian  :(  de todas maneras es una pena por que ya tenias hecho un buen trozo de codigo, aunque las funciones de borrar, buscar,almacenar teseguiran valiendo, con algun retoque

Siento darte "malas" noticias pero tranqui que lo de acceso a archivos es mas facil que lo de las listas enlazadas, para mi gusto, si tienes algun problema con el manejo de archivos dimelo, que no se me da del todo mal.

Un saludo :hola:  y animo que no hay nada imposible  :rolleyes:  a programar ¡¡  :comp:
Por favor, ya lei lo que me pusiste, me puedes echar una mano, es que no se por dodne empezar, entonces que tengo que quitar todas las funciones, no están bien, además de estar mal porque falta la funcion grabar lista, el resto del codigo, esta mal. Por favor, ayudame, que estoy muy apurada. Gracias
Saludos

50
C/C++ / Re: Duda De Listas Simples En C
« en: Domingo 14 de Noviembre de 2004, 21:01 »
Cita de: "Diodo"
Hola Maria  :hola:

Lo siento pero creo que no has leido bien el enunciado de la practica  :(  

Realiza un programa en C para gestionar los datos incluidos en un fichero de tipo texto mediante una lista simplemente enlazada.

por eso no te cuadra el apartado 11

11. grabarLista: graba los datos de la lista en un fichero binario. El nombre del fichero debe ser tomado del argumento en la línea de comandos. La función tendrá como parámetros la lista y el nombre del fichero.

En mi opinion lo que tienes que hacer es un programa que lea los datos de un archivo de texto "fichero.txt o fichero.dat" que esta en el disco duro de tu ordenador, entonces carga esos datos a una lista para poder operar con ellos, buscar por apellido, borrar registros, etc y finalmente si el usuario quiere ,volver a grabar los datos en un nuevo archivo, y asi los datos no se pierdan al finalizar la aplicacion

Sera mejor que preguntes a quien te haya mandado hacer la practica , si es eso lo que te pedian  :(  de todas maneras es una pena por que ya tenias hecho un buen trozo de codigo, aunque las funciones de borrar, buscar,almacenar teseguiran valiendo, con algun retoque

Siento darte "malas" noticias pero tranqui que lo de acceso a archivos es mas facil que lo de las listas enlazadas, para mi gusto, si tienes algun problema con el manejo de archivos dimelo, que no se me da del todo mal.

Un saludo :hola:  y animo que no hay nada imposible  :rolleyes:  a programar ¡¡  :comp:
Te agradezco tu pronta respuesta, tiens razón no lei bien, el enunciado de la practica. Me podrías ayudar a comenzar a modificarla, es que estoy un poco perdida. Tengo el examen en diciembre, y esta vez tengo que aprobar como sea. Gracias, espero tu respuesta.
Saludos

Páginas: 1 [2] 3 4 5