Foro de elhacker.net

Programación => Programación C/C++ => Mensaje iniciado por: m@o_614 en 15 Enero 2014, 19:51 pm


Título: Lista con arrays
Publicado por: m@o_614 en 15 Enero 2014, 19:51 pm
Saludos tengo el siguiente archivo de texto:

ADCA****SI***IMM***89ii******1***1***2
**************DIR***99dd*****1***1***2   
**************EXT***B9hhll****1***2***3   
**************IDX***A9xb*****1***1***2   
**************IDX1**A9xbff****1***2***3   
**************IDX2**A9xbeeff**1***3***4   

los * son espacios
Y tengo que leer este archivo y que me guarde cada uno de los elementos en una variable para esto se me ocurrio que podia hacer una lista simplemente ligada que tuviera los elementos:

codop = ADCA, operando = SI y para los 5 elementos restantes pense que podria hacerlos con arreglos, que direccionamiento fuera algo como:

direc[0] = IMM
direc[1] = DIR
direc[2] = EXT
direc[3] = IDX
direc[4] = IDX1
 
y codigo maquina fuera:

maq[0] = 89ii
maq[1] = 99dd
maq[2] = B9hhl
....
....
esto seria un array de cadenas un char **direc y para los campos que tienen numeros seria un simple array, el codigo que tengo hecho es el siguiente pero me aparecen warnings que dicen assignment makes integer from pointer without a cast, y no entiendo por que,¿¿¿como corregirlo???

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. typedef struct nodo
  6. {
  7.     char *codigo;
  8.     char *Operando;
  9.     char **modo_direccionamiento;
  10.     char **codigo_maquina;
  11.     char *bytes_calculados;
  12.     char *bytes_x_calcular;
  13.     char *total_bytes;
  14.     struct nodo *sig;
  15. }COD;
  16.  
  17. void buscarFinLinea(FILE *hc12);
  18. void ignorarEspacios(FILE *hc12);
  19. char *Tabla_Operandos(FILE *hc12);
  20. void insertarFinal(char *ins,char *op,char **dir,char **maq,char *calculado,char *calcular,char *total,COD *ultimo,int i);
  21. COD *ultimoElemento(COD *cabeza);
  22. COD *crearNodo(char *ins,char *op,char **dir,char **maq,char *calculado,char *calcular,char *total,int i);
  23. void quitarSaltosLinea(char *cadena);
  24.  
  25. int main()
  26. {
  27.     COD *cabeza = NULL,*ultimo;
  28.     FILE *hc12;
  29.     int p,i,car;
  30.     char *ins,*op,**dir,**maq,*calculado,*calcular,*total;
  31.     if((hc12 = fopen("archivo.txt","r"))!= NULL)
  32.     {
  33.         i = 0;
  34.         while((car = fgetc(hc12))!= EOF)
  35.         {
  36.             if(car != '\t')
  37.             {
  38.                 ins = Tabla_Operandos(hc12);
  39.                 ignorarEspacios(hc12);
  40.                 op = Tabla_Operandos(hc12);
  41.                 ignorarEspacios(hc12);
  42.                 p = ftell(hc12);
  43.                 buscarFinLinea(hc12);
  44.                 if(car == '\t')
  45.                 {
  46.                     fseek(hc12,p,SEEK_SET);
  47.                     dir = (char**)malloc(8*sizeof(char));
  48.                     dir[i] = Tabla_Operandos(hc12);
  49.                     ignorarEspacios(hc12);
  50.                     maq = (char**)malloc(8*sizeof(char));
  51.                     maq[i] = Tabla_Operandos(hc12);
  52.                     ignorarEspacios(hc12);
  53.                     calculado = (char*)malloc(8*sizeof(char));
  54.                     calculado[i] = Tabla_Operandos(hc12);
  55.                     ignorarEspacios(hc12);
  56.                     calcular = (char*)malloc(8*sizeof(char));
  57.                     calcular[i] = Tabla_Operandos(hc12);
  58.                     ignorarEspacios(hc12);
  59.                     total = (char*)malloc(8*sizeof(char));
  60.                     total[i] = Tabla_Operandos(hc12);
  61.                     buscarFinLinea(hc12);
  62.                     if(cabeza == NULL)
  63.                        //cabeza = crearNodo(ins,op,dir,maq,calculado,calcular,total,i);
  64.                     else
  65.                     {
  66.                         //ultimo = ultimoElemento(cabeza);
  67.                         //insertarFinal(ins,op,dir,maq,calculado,calcular,total,ultimo);
  68.                     }
  69.                     i++;
  70.                 }
  71.             }
  72.         }
  73.     }
  74.     else
  75.        printf("No se pudo abrir archivo\n");
  76.     return 0;
  77. }
  78.  
  79. void buscarFinLinea(FILE *fd)
  80. {
  81.     int car;
  82.     while((car = fgetc(fd))!= '\n')
  83.         ;
  84. }
  85.  
  86. void ignorarEspacios(FILE *fd)
  87. {
  88.     int car;
  89.     do
  90.     {
  91.         car = fgetc(fd);
  92.     }while(car == '\t' || car == ' ');
  93. }
  94.  
  95. char *Tabla_Operandos(FILE *hc12)
  96. {
  97.     int car,lon = 0,pos;
  98.     char *cadena;
  99.     fseek(hc12,-1,SEEK_CUR);
  100.     pos = ftell(hc12);
  101.     do
  102.     {
  103.         car = fgetc(hc12);
  104.         lon++;
  105.     }while(car != '\t');
  106.     fseek(hc12,pos,SEEK_SET);
  107.     cadena = (char*)calloc((lon+1),sizeof(char));
  108.     fgets(cadena,lon+1,hc12);
  109.     quitarSaltosLinea(cadena);
  110.     return cadena;
  111. }
  112.  
  113. void quitarSaltosLinea(char *cadena)
  114. {
  115.     char *ptr;
  116.     if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
  117.        *ptr = '\0';
  118. }
  119.  
  120.  

de antemano gracias

Título: Re: Lista con arrays
Publicado por: ivancea96 en 15 Enero 2014, 20:26 pm
En que linea el warning?

Título: Re: Lista con arrays
Publicado por: m@o_614 en 16 Enero 2014, 01:18 am
las lineas de warning aparecen en las variables
Código
  1. calculado[i] = Tabla_Operandos(hc12);
y tambien en
Código
  1. calcular[i] = Tabla_Operandos(hc12);
y la de total.

si hago el codigo de esta manera:

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. typedef struct nodo
  6. {
  7.     char *codigo;
  8.     char *Operando;
  9.     char *modo_direccionamiento;
  10.     char *codigo_maquina;
  11.     char *bytes_calculados;
  12.     char *bytes_x_calcular;
  13.     char *total_bytes;
  14.     struct nodo *sig;
  15. }COD;
  16.  
  17. void imprimirLista(COD *cabeza);
  18. void buscarFinLinea(FILE *hc12);
  19. void ignorarEspacios(FILE *hc12);
  20. char *Tabla_Operandos(FILE *hc12);
  21. void insertarFinal(char *ins,char *op,char *dir,char *maq,char *calculado,char *calcular,char *total,COD *ultimo);
  22. COD *ultimoElemento(COD *cabeza);
  23. COD *crearNodo(char *ins,char *op,char *dir,char *maq,char *calculado,char *calcular,char *total);
  24. void quitarSaltosLinea(char *cadena);
  25.  
  26. int main()
  27. {
  28.     COD *cabeza = NULL,*ultimo;
  29.     FILE *hc12;
  30.     int car;
  31.     char *ins,*op,*dir,*maq,*calculado,*calcular,*total;
  32.     if((hc12 = fopen("archivo.txt","r"))!= NULL)
  33.     {
  34.         while((car = fgetc(hc12))!= EOF)
  35.         {
  36.             if(car != '\t')
  37.             {
  38.                 ins = Tabla_Operandos(hc12);
  39.                 ignorarEspacios(hc12);
  40.                 op = Tabla_Operandos(hc12);
  41.                 ignorarEspacios(hc12);
  42.                 dir = Tabla_Operandos(hc12);
  43.                 ignorarEspacios(hc12);
  44.                 maq = Tabla_Operandos(hc12);
  45.                 ignorarEspacios(hc12);
  46.                 calculado = Tabla_Operandos(hc12);
  47.                 ignorarEspacios(hc12);
  48.                 calcular = Tabla_Operandos(hc12);
  49.                 ignorarEspacios(hc12);
  50.                 total = Tabla_Operandos(hc12);
  51.                 buscarFinLinea(hc12);
  52.                 if(cabeza == NULL)
  53.                    cabeza = crearNodo(ins,op,dir,maq,calculado,calcular,total);
  54.                 else
  55.                 {
  56.                     ultimo = ultimoElemento(cabeza);
  57.                     insertarFinal(ins,op,dir,maq,calculado,calcular,total,ultimo);
  58.                 }
  59.             }
  60.             else
  61.                buscarFinLinea(hc12);
  62.         }
  63.         imprimirLista(cabeza);
  64.     }
  65.     else
  66.        printf("No se pudo abrir archivo\n");
  67.     return 0;
  68. }
  69.  
  70. void buscarFinLinea(FILE *fd)
  71. {
  72.     int car;
  73.     while((car = fgetc(fd))!= '\n')
  74.         ;
  75. }
  76.  
  77. void ignorarEspacios(FILE *fd)
  78. {
  79.     int car;
  80.     do
  81.     {
  82.         car = fgetc(fd);
  83.     }while(car == '\t' || car == ' ');
  84. }
  85.  
  86. char *Tabla_Operandos(FILE *hc12)
  87. {
  88.     int car,lon = 0,pos;
  89.     char *cadena;
  90.     fseek(hc12,-1,SEEK_CUR);
  91.     pos = ftell(hc12);
  92.     do
  93.     {
  94.         car = fgetc(hc12);
  95.         lon++;
  96.     }while(car != '\t');
  97.     fseek(hc12,pos,SEEK_SET);
  98.     cadena = (char*)calloc((lon+1),sizeof(char));
  99.     fgets(cadena,lon+1,hc12);
  100.     quitarSaltosLinea(cadena);
  101.     return cadena;
  102. }
  103.  
  104. void quitarSaltosLinea(char *cadena)
  105. {
  106.     char *ptr;
  107.     if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
  108.        *ptr = '\0';
  109. }
  110.  
  111. void insertarFinal(char *ins,char *op,char *dir,char *maq,char *calculado,char *calcular,char *total,COD *ultimo)
  112. {
  113.     ultimo->sig = crearNodo(ins,op,dir,maq,calculado,calcular,total);
  114.     ultimo->sig->sig = NULL;
  115.     ultimo = ultimo->sig;
  116. }
  117.  
  118. COD *ultimoElemento(COD *cabeza)
  119. {
  120.     COD *ptr;
  121.     ptr = cabeza;
  122.     while(ptr->sig != NULL)
  123.        ptr = ptr->sig;
  124.     return ptr;
  125. }
  126.  
  127. COD *crearNodo(char *ins,char *op,char *dir,char *maq,char *calculado,char *calcular,char *total)
  128. {
  129.     COD *x;
  130.     int tam,tam1,tam2,tam3,tam4,tam5,tam6;
  131.     tam = strlen(ins);
  132.     tam1 = strlen(op);
  133.     tam2 = strlen(dir);
  134.     tam3 = strlen(maq);
  135.     tam4 = strlen(calculado);
  136.     tam5 = strlen(calcular);
  137.     tam6 = strlen(total);
  138.     x = (COD*)malloc(sizeof(COD));
  139.     x->codigo = (char*)malloc((tam+1)*sizeof(char));
  140.     x->Operando = (char*)malloc((tam1+1)*sizeof(char));
  141.     x->modo_direccionamiento = (char*)malloc((tam2+1)*sizeof(char));
  142.     x->codigo_maquina = (char*)malloc((tam3+1)*sizeof(char));
  143.     x->bytes_calculados = (char*)malloc((tam4+1)*sizeof(char));
  144.     x->bytes_x_calcular = (char*)malloc((tam5+1)*sizeof(char));
  145.     x->total_bytes = (char*)malloc((tam6+1)*sizeof(char));
  146.     strcpy(x->codigo,ins);
  147.     strcpy(x->Operando,op);
  148.     strcpy(x->modo_direccionamiento,dir);
  149.     strcpy(x->codigo_maquina,maq);
  150.     strcpy(x->bytes_calculados,calculado);
  151.     strcpy(x->bytes_x_calcular,calcular);
  152.     strcpy(x->total_bytes,total);
  153.     x->sig = NULL;
  154.     return x;
  155. }
  156.  
  157. void imprimirLista(COD *cabeza)
  158. {
  159.     COD *ptr;
  160.     for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
  161.     {
  162.         printf("%s\t",ptr->codigo);
  163.         printf("%s\t",ptr->Operando);
  164.         printf("%s\t",ptr->modo_direccionamiento);
  165.         printf("%s\t\t",ptr->codigo_maquina);
  166.         printf("%s\t",ptr->bytes_calculados);
  167.         printf("%s\t",ptr->bytes_x_calcular);
  168.         printf("%s\n",ptr->total_bytes);
  169.     }
  170. }
  171.  

funciona correctamente y me imprime la primer linea del archivo:

codop    operan  direccionamiento   cod maquina   bytes     etc    etc
ADCA     SI        IMM                        89ii        1          1   2   

pero no me imprime los demas lineas, es por eso que queria que los direccionamientos, codigos maquina, etc... fueran arrays para que asi cupieran todos, pero no se como hacer para que  las variables dir, maq, calculado, calcular, total me puedan almacenar un solo elemento y despues poder modificarla para que sea un array, no se si me di a entender espero que si :(



Título: Re: Lista con arrays
Publicado por: rir3760 en 16 Enero 2014, 02:12 am
Ya te había comentado en otros temas que utilizar fseek en un archivo abierto en modo texto no es una buena idea.

El error que mencionas se genera en las lineas:
Código
  1. calculado[i] = Tabla_Operandos(hc12);
  2. ...
  3. calcular[i] = Tabla_Operandos(hc12);
  4. ...
  5. total[i] = Tabla_Operandos(hc12);
Y se genera porque "calculado[ i ]", "calcular[ i ]" y "total[ i ]" son (expresiones) de tipo char mientras que el tipo de retorno de la función "Tabla_Operandos" es "char *".

Un saludo

Título: Re: Lista con arrays
Publicado por: m@o_614 en 16 Enero 2014, 19:19 pm
gracias rir3760 tratare de pensar en alguna manera de sustituir el fseek aunque por ahora no se me ocurre nada, tambien le hice modificaciones al codigo y ya no me aparecen errores ni warnings pero el codigo me truena no entiendo por que

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. typedef struct nodo
  6. {
  7.     char *codigo;
  8.     char *Operando;
  9.     char *modo_direccionamiento[8];
  10.     char *codigo_maquina[8];
  11.     char *bytes_calculados[8];
  12.     char *bytes_x_calcular[8];
  13.     char *total_bytes[8];
  14.     struct nodo *sig;
  15. }COD;
  16.  
  17. void imprimirLista(COD *cabeza);
  18. void buscarFinLinea(FILE *hc12);
  19. void ignorarEspacios(FILE *hc12);
  20. char *Tabla_Operandos(FILE *hc12);
  21. void insertarFinal(char *ins,char *op,char **dir,char **maq,char **calculado,char **calcular,char **total,COD *ultimo,int i);
  22. COD *ultimoElemento(COD *cabeza);
  23. COD *crearNodo(char *ins,char *op,char **dir,char **maq,char **calculado,char **calcular,char **total,int i);
  24. void quitarSaltosLinea(char *cadena);
  25.  
  26. int main()
  27. {
  28.     COD *cabeza = NULL,*ultimo;
  29.     FILE *hc12;
  30.     int car,i;
  31.     char *ins,*op,*dir[8],*maq[8],*calculado[8],*calcular[8],*total[8];
  32.     if((hc12 = fopen("archivo.txt","r"))!= NULL)
  33.     {
  34.         i = 0;
  35.         while((car = fgetc(hc12))!= EOF)
  36.         {
  37.             if(car != '\t')
  38.             {
  39.                 ins = Tabla_Operandos(hc12);
  40.                 ignorarEspacios(hc12);
  41.                 op = Tabla_Operandos(hc12);
  42.                 ignorarEspacios(hc12);
  43.                 dir[i] = Tabla_Operandos(hc12);
  44.                 ignorarEspacios(hc12);
  45.                 maq[i] = Tabla_Operandos(hc12);
  46.                 ignorarEspacios(hc12);
  47.                 calculado[i] = Tabla_Operandos(hc12);
  48.                 ignorarEspacios(hc12);
  49.                 calcular[i] = Tabla_Operandos(hc12);
  50.                 ignorarEspacios(hc12);
  51.                 total[i] = Tabla_Operandos(hc12);
  52.                 buscarFinLinea(hc12);
  53.                 i++;
  54.                 if(cabeza == NULL)
  55.                    cabeza = crearNodo(ins,op,dir,maq,calculado,calcular,total,i);
  56.                 else
  57.                 {
  58.                     ultimo = ultimoElemento(cabeza);
  59.                     insertarFinal(ins,op,dir,maq,calculado,calcular,total,ultimo,i);
  60.                 }
  61.             }
  62.             else
  63.             {/*
  64.                 dir[i] = Tabla_Operandos(hc12);
  65.                 ignorarEspacios(hc12);
  66.                 maq[i] = Tabla_Operandos(hc12);
  67.                 ignorarEspacios(hc12);
  68.                 calculado[i] = Tabla_Operandos(hc12);
  69.                 ignorarEspacios(hc12);
  70.                 calcular[i] = Tabla_Operandos(hc12);
  71.                 ignorarEspacios(hc12);
  72.                 total[i] = Tabla_Operandos(hc12);
  73.                 i++;*/
  74.                 buscarFinLinea(hc12);
  75.             }
  76.         }
  77.         //imprimirLista(cabeza);
  78.     }
  79.     else
  80.        printf("No se pudo abrir archivo\n");
  81.     return 0;
  82. }
  83.  
  84. void buscarFinLinea(FILE *fd)
  85. {
  86.     int car;
  87.     while((car = fgetc(fd))!= '\n')
  88.         ;
  89. }
  90.  
  91. void ignorarEspacios(FILE *fd)
  92. {
  93.     int car;
  94.     do
  95.     {
  96.         car = fgetc(fd);
  97.     }while(car == '\t' || car == ' ');
  98. }
  99.  
  100. char *Tabla_Operandos(FILE *hc12)
  101. {
  102.     int car,lon = 0,pos;
  103.     char *cadena;
  104.     fseek(hc12,-1,SEEK_CUR);
  105.     pos = ftell(hc12);
  106.     do
  107.     {
  108.         car = fgetc(hc12);
  109.         lon++;
  110.     }while(car != '\t');
  111.     fseek(hc12,pos,SEEK_SET);
  112.     cadena = (char*)calloc((lon+1),sizeof(char));
  113.     fgets(cadena,lon+1,hc12);
  114.     quitarSaltosLinea(cadena);
  115.     return cadena;
  116. }
  117.  
  118. void quitarSaltosLinea(char *cadena)
  119. {
  120.     char *ptr;
  121.     if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
  122.        *ptr = '\0';
  123. }
  124.  
  125. void insertarFinal(char *ins,char *op,char **dir,char **maq,char **calculado,char **calcular,char **total,COD *ultimo,int i)
  126. {
  127.     ultimo->sig = crearNodo(ins,op,dir,maq,calculado,calcular,total,i);
  128.     ultimo->sig->sig = NULL;
  129.     ultimo = ultimo->sig;
  130. }
  131.  
  132. COD *ultimoElemento(COD *cabeza)
  133. {
  134.     COD *ptr;
  135.     ptr = cabeza;
  136.     while(ptr->sig != NULL)
  137.        ptr = ptr->sig;
  138.     return ptr;
  139. }
  140.  
  141. COD *crearNodo(char *ins,char *op,char **dir,char **maq,char **calculado,char **calcular,char **total,int i)
  142. {
  143.     COD *x;
  144.     int tam,tam1,tam2,tam3,tam4,tam5,tam6;
  145.     tam = strlen(ins);
  146.     tam1 = strlen(op);
  147.     tam2 = strlen(dir[i]);
  148.     tam3 = strlen(maq[i]);
  149.     tam4 = strlen(calculado[i]);
  150.     tam5 = strlen(calcular[i]);
  151.     tam6 = strlen(total[i]);
  152.     x = malloc(sizeof(COD));
  153.     x->codigo = (char*)malloc(tam+1);
  154.     x->Operando = (char*)malloc(tam1+1);
  155.     x->modo_direccionamiento[i] = (char*)malloc(tam2+1);
  156.     x->codigo_maquina[i] = (char*)malloc(tam3+1);
  157.     x->bytes_calculados[i] = (char*)malloc(tam4+1);
  158.     x->bytes_x_calcular[i] = (char*)malloc(tam5+1);
  159.     x->total_bytes[i] = (char*)malloc(tam6+1);
  160.     strcpy(x->codigo,ins);
  161.     strcpy(x->Operando,op);
  162.     strcpy(x->modo_direccionamiento[i],dir[i]);
  163.     strcpy(x->codigo_maquina[i],maq[i]);
  164.     strcpy(x->bytes_calculados[i],calculado[i]);
  165.     strcpy(x->bytes_x_calcular[i],calcular[i]);
  166.     strcpy(x->total_bytes[i],total[i]);
  167.     x->sig = NULL;
  168.     return x;
  169. }


Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines