elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: (TUTORIAL) Aprende a emular Sentinel Dongle By Yapis


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  problema con lista indexada
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: problema con lista indexada  (Leído 3,260 veces)
m@o_614


Desconectado Desconectado

Mensajes: 389


Ver Perfil
problema con lista indexada
« en: 4 Enero 2014, 01:37 am »

Saludos, estoy haciendo una lista simplemente ligada la cual tiene un campo indice para que cada que vaya agregando un elemento sepa cuantos elementos tiene. El problema es que cuando inicializo ese campo a 0 dentro de la structura me aparece un error
Código
  1. typedef struct nodo
  2. {
  3.    char *codigo;
  4.    int indice = 0;
  5.    struct nodo *sig;
  6. }NODO;

me dice que expected ':', ','...... or attribute before token

gracias


En línea

ivancea96


Desconectado Desconectado

Mensajes: 3.412


ASMático


Ver Perfil WWW
Re: problema con lista indexada
« Respuesta #1 en: 4 Enero 2014, 01:42 am »

Las variables de las estructuras y clases se inicializan en el constructor y demás funciones. No se puede crear ya inicializada.


En línea

amchacon


Desconectado Desconectado

Mensajes: 1.211



Ver Perfil
Re: problema con lista indexada
« Respuesta #2 en: 4 Enero 2014, 01:49 am »

¿Lenguaje?

En C no se pueden inicializar los miembros de estructura en la declaración, tienes que inicializarlas cuando la crees.

En C++ se pueden inicializar desde los constructores, o directamente en la declaración si la variable es static.

En C++11 puedes inicializar todas las variables en la declaración.
En línea

Por favor, no me manden MP con dudas. Usen el foro, gracias.

¡Visita mi programa estrella!

Rar File Missing: Esteganografía en un Rar
m@o_614


Desconectado Desconectado

Mensajes: 389


Ver Perfil
Re: problema con lista indexada
« Respuesta #3 en: 4 Enero 2014, 04:15 am »

gracias por sus respuestas, es en lenguaje C.

preguntaba lo de los indices porque queria hacer una busqueda binaria con una lista enlazada y necesitaba saber el número total de elementos, pero mejor voy a hacer la busqueda secuencial. Una ultima duda si ya tengo hecha la lista enlazada y quiero buscar un elemento,le paso a la funcion de buscar() el puntero que apunta al primer nodo y despues voy recorriendo la lista para ver si se encuentra el elemento, pero el problema es que el codigo siempre me imprime NO SE ENCONTRO EL CODOP DE OPERACION y no entiendo por que

Código
  1. typedef struct nodo
  2. {
  3.    char *codigo;
  4.    struct nodo *sig;
  5. }CODOP;
  6.  
  7. void buscarCodop(CODOP *cabeza)
  8. {
  9.    CODOP *ptr;
  10.    char *codop = "BLE";
  11.    int encontrado = 0;
  12.    for(ptr = cabeza;(ptr != NULL)&&(encontrado);ptr = ptr->sig)
  13.    {
  14.        if((strcmp(ptr->codigo,codop)) == 0)
  15.           encontrado = 1;
  16.    }
  17.    if(encontrado == 0)
  18.       printf("\nNO SE ENCONTRO EL CODOP DE OPERACION\n");
  19.    else
  20.       printf("\nNO SE ENCONTRO EL CODOP DE OPERACION\n");
  21. }
  22.  

esta es la parte que me da problemas, no posteo todo el codigo porque son como 360 lineas

gracias
« Última modificación: 4 Enero 2014, 04:27 am por m@o_614 » En línea

do-while


Desconectado Desconectado

Mensajes: 1.276


¿Habra que sacarla de paseo?


Ver Perfil
Re: problema con lista indexada
« Respuesta #4 en: 4 Enero 2014, 10:36 am »

¡Buenas!

Tienes un error aquí:
Código
  1.    int encontrado = 0;
  2.   for(ptr = cabeza;(ptr != NULL)&&(encontrado);ptr = ptr->sig)
  3.  

Si inicializas encontrado a cero y luego como condición de continuidad en el for utilizas que encontrado sea distinto de cero, nunca vas a ejecutar una sola iteración, ya que la primera comprobación de las condiciones siempre será falsa. Tienes que asumir que el elemento existe y decir que no existe solo si has recorrido toda la lista.

¡Saludos!
En línea

- Doctor, confundo los números y los colores.
- Vaya marrón.
- ¿Marrón? ¡Por el culo te la hinco!
rir3760


Desconectado Desconectado

Mensajes: 1.639


Ver Perfil
Re: problema con lista indexada
« Respuesta #5 en: 4 Enero 2014, 19:28 pm »

Extendiendo la solución de do-while puedes eliminar el cuerpo del bucle si en su condición colocas la comparación con strcmp. Ademas no es necesario declarar la variable local "ptr" cuando puedes utilizar el parámetro "cabeza" y el mensaje que imprimes se encuentre o no la cadena es el mismo.

Con los cambios:
Código
  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. typedef struct nodo
  5. {
  6.   char *codigo;
  7.   struct nodo *sig;
  8. } CODOP;
  9.  
  10. void buscarCodop(CODOP *p)
  11. {
  12.   while (p != NULL && strcmp(p->codigo, "BLE") != 0)
  13.      p = p->sig;
  14.  
  15.   if (p)
  16.      puts("Se encontro el codop");
  17.   else
  18.      puts("No se encontro el codop");
  19. }

Eso en el caso de una lista vinculada sin ordenar, si los nodos están ordenados la búsqueda debe terminar en cuanto el puntero sea NULL o se encuentre un nodo con un valor igual o mayor al buscado.

Un saludo
En línea

C retains the basic philosophy that programmers know what they are doing; it only requires that they state their intentions explicitly.
--
Kernighan & Ritchie, The C programming language
m@o_614


Desconectado Desconectado

Mensajes: 389


Ver Perfil
Re: problema con lista indexada
« Respuesta #6 en: 8 Enero 2014, 00:08 am »

gracias por sus respuestas, una ultima duda, si tengo por ejemplo el archivo

*****ORG***$AB
Et1**SWI*******
*****ADCA**1,X
*****BRA***ET1

los codops son (ORG,SWI,ADCA,BRA) y cada uno de esos los tengo que buscar en una lista, en este ejemplo el unico codop que no se debe de encontrar es el ORG, pero en el codigo siempre me aparece NO SE ENCONTRO EL CODOP DE OPERACION, ya cheque que la funcion busqueda este bien implementada pero aun asi no puedo encontrar cual es el fallo

Código
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #define LONG_ETIQUETA 8
  5. #define LONG_CODOP 5
  6. #define COMENTARIO ';'
  7. #define TABULADOR '\t'
  8. #define ESPACIOS_ ' '
  9.  
  10. typedef enum {FALSO,VERDADERO} booleano;
  11. typedef enum {ETIQUETA,CODOP,OPERANDO} linea;
  12. typedef enum {INS,OPE} tabla;
  13.  
  14. typedef struct nodo
  15. {
  16.    char *codigo;
  17.    char *Operando;
  18.    struct nodo *sig;
  19. }COD;
  20.  
  21. COD *crearNodo(char *instruccion,char *op);
  22. void insertarFinal(char *instruccion,char *op,COD *ultimo);
  23. COD *ultimoElemento(COD *cabeza);
  24. void quitarSaltosLinea(char *cadena);
  25. int verificarCombinacion(FILE *fd);
  26. booleano esComentario(FILE *fd);
  27. char *Etiqueta_Codop_Operando(FILE *fd,int linea);
  28. char *_Codop_Operando(FILE *fd,int linea);
  29. void ultimaLinea(char *codop);
  30. void erroresEtiqueta(char *etiqueta);
  31. void erroresCodop(char *codop);
  32. void buscarFinLinea(FILE *fd);
  33. void ignorarEspacios(FILE *fd);
  34. booleano esNumero(char caracter);
  35. booleano esLetra(char caracter);
  36. void listaCodops(COD *cabeza);
  37. char *Tabla_Operandos(FILE *hc12,int tabla);
  38. COD *buscarCodop(COD *cabeza,char *codop);
  39. void imprimirLista(COD *cabeza);
  40.  
  41. int main()
  42. {
  43.    FILE *fd;
  44.    int car,combinacion;
  45.    COD *cabeza = NULL,*encontrado;
  46.    char *etiqueta,*codop,*operando;
  47.    //listaCodops(cabeza);
  48.    if((fd = fopen("P2ASM.txt","r"))!= NULL)
  49.    {
  50.        while((car = fgetc(fd))!= EOF)
  51.        {
  52.            switch(car)
  53.            {
  54.                case COMENTARIO:
  55.                   if(esComentario(fd))
  56.                      printf("COMENTARIO\n\n");
  57.                   else
  58.                      buscarFinLinea(fd);
  59.                   break;
  60.                case ESPACIOS_:
  61.                case TABULADOR:
  62.                   etiqueta = "null";
  63.                   printf("ETIQUETA = %s\n",etiqueta);
  64.                   ignorarEspacios(fd);
  65.                   codop = Etiqueta_Codop_Operando(fd,CODOP);
  66.                   printf("CODOP = %s\n",codop);
  67.                   erroresCodop(codop);
  68.                   if((encontrado = buscarCodop(cabeza,codop)) == NULL)
  69.                      printf("\tNO SE ENCONTRO EL CODOP DE OPERACION\n");
  70.                   combinacion = verificarCombinacion(fd);
  71.                   if(combinacion == 2)
  72.                   {
  73.                       operando = "null";
  74.                       printf("OPERANDO = %s\n\n",operando);
  75.                   }
  76.                   else
  77.                   {
  78.                       ignorarEspacios(fd);
  79.                       operando = Etiqueta_Codop_Operando(fd,OPERANDO);
  80.                       printf("OPERANDO = %s\n\n",operando);
  81.                   }
  82.                   break;
  83.                default:
  84.                   etiqueta = Etiqueta_Codop_Operando(fd,ETIQUETA);
  85.                   printf("ETIQUETA = %s\n",etiqueta);
  86.                   erroresEtiqueta(etiqueta);
  87.                   combinacion = verificarCombinacion(fd);
  88.                   if(combinacion == 2)
  89.                   {
  90.                       codop = "null";
  91.                       printf("CODOP = %s\n",codop);
  92.                       erroresCodop(codop);
  93.                       if((encontrado = buscarCodop(cabeza,codop)) == NULL)
  94.                          printf("\tNO SE ENCONTRO EL CODOP DE OPERACION\n");
  95.                       operando = "null";
  96.                       printf("OPERANDO = %s\n\n",operando);
  97.                   }
  98.                   else
  99.                   {
  100.                       ignorarEspacios(fd);
  101.                       codop = Etiqueta_Codop_Operando(fd,CODOP);
  102.                       printf("CODOP = %s\n",codop);
  103.                       erroresCodop(codop);
  104.                       if((encontrado = buscarCodop(cabeza,codop)) == NULL)
  105.                          printf("\tNO SE ENCONTRO EL CODOP DE OPERACION\n");
  106.                       combinacion = verificarCombinacion(fd);
  107.                       if(combinacion == 2)
  108.                       {
  109.                           operando = "null";
  110.                           printf("OPERANDO = %s\n\n",operando);
  111.                       }
  112.                       else
  113.                       {
  114.                           ignorarEspacios(fd);
  115.                           operando = Etiqueta_Codop_Operando(fd,OPERANDO);
  116.                           printf("OPERANDO = %s\n\n",operando);
  117.                       }
  118.                   }
  119.                   break;
  120.            }
  121.        }
  122.        ultimaLinea(codop);
  123.    }
  124.    else
  125.       printf("No se pudo abrir el archivo");
  126.    return 0;
  127. }
  128.  
  129. booleano esComentario(FILE *fd)
  130. {
  131.    int car;
  132.    while((car = fgetc(fd))!= '\n')
  133.    {
  134.        if(car == ';')
  135.           return 0;
  136.    }
  137.    return 1;
  138. }
  139.  
  140. void buscarFinLinea(FILE *fd)
  141. {
  142.    int car;
  143.    while((car = fgetc(fd))!= '\n')
  144.        ;
  145. }
  146.  
  147. void ignorarEspacios(FILE *fd)
  148. {
  149.    int car;
  150.    do
  151.    {
  152.        car = fgetc(fd);
  153.    }while(car == '\t' || car == ' ');
  154. }
  155.  
  156. int verificarCombinacion(FILE *fd)
  157. {
  158.    int car,combinacion;
  159.    fseek(fd,-1,SEEK_CUR);
  160.    if((car = fgetc(fd))== '\n')
  161.       combinacion = 2;
  162.    else
  163.       combinacion = 1;
  164.    return combinacion;
  165. }
  166.  
  167. booleano esLetra(char caracter)
  168. {
  169.    if((caracter >= 'A' && caracter <= 'Z')||(caracter >= 'a' && caracter <= 'z'))
  170.       return 1;
  171.    else
  172.       return 0;
  173. }
  174.  
  175. booleano esNumero(char caracter)
  176. {
  177.    if(caracter >= '0' && caracter <= '9')
  178.       return 1;
  179.    else
  180.       return 0;
  181. }
  182.  
  183. char *Etiqueta_Codop_Operando(FILE *fd,int linea)
  184. {
  185.    int car,lon = 0,pos;
  186.    char *cadena;
  187.    fseek(fd,-1,SEEK_CUR);
  188.    pos = ftell(fd);
  189.    if((linea == ETIQUETA)||(linea == CODOP))
  190.    {
  191.        do
  192.        {
  193.            car = fgetc(fd);
  194.            lon++;
  195.        }while(car != '\t' && car != ' ' && car != '\n');
  196.    }
  197.    else
  198.    {
  199.        do
  200.        {
  201.            car = fgetc(fd);
  202.            lon++;
  203.        }while(car != '\n');
  204.    }
  205.    cadena = calloc(lon+1);
  206.    fseek(fd,pos,SEEK_SET);
  207.    fgets(cadena,lon+1,fd);
  208.    quitarSaltosLinea(cadena);
  209.    return cadena;
  210. }
  211.  
  212. void quitarSaltosLinea(char *cadena)
  213. {
  214.    char *ptr;
  215.    if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
  216.       *ptr = '\0';
  217. }
  218.  
  219. void erroresEtiqueta(char *etiqueta)
  220. {
  221.    int tam,i = 0,esEtiqueta = 1;
  222.    tam = strlen(etiqueta);
  223.    if(tam-1 > LONG_ETIQUETA)
  224.       printf("\tError:la longitud maxima de una etiqueta es de 8 caracteres\n");
  225.    if(!esLetra(etiqueta[i]))
  226.       printf("\tError:la etiqueta debe iniciar con letra\n");
  227.    else
  228.    {
  229.        for(i = 0;(i < tam)&&(esEtiqueta);i++)
  230.        {
  231.           if((!esLetra(etiqueta[i]))&&(!esNumero(etiqueta[i]))&&(etiqueta[i] != '_'))
  232.              esEtiqueta = 0;
  233.        }
  234.        if(!esEtiqueta)
  235.           printf("\tError:los caracteres validos en las etiquetas son letras, digitos(0..9) y el guion bajo\n");
  236.    }
  237. }
  238.  
  239. void erroresCodop(char *codop)
  240. {
  241.    int tam,i = 0,esCodop = 1,punto = 0;
  242.    tam = strlen(codop);
  243.    if(tam > LONG_CODOP)
  244.       printf("\tError:la longitud maxima de un codigo de operacion es de 5 caracteres\n");
  245.    if((strcmp(codop,"null"))== 0)
  246.       printf("\tError:siempre debe de haber un codigo de operacion\n");
  247.    else
  248.    {
  249.        if(!esLetra(codop[i]))
  250.        printf("\tError:los codigos de operacion deben iniciar con letra\n");
  251.        else
  252.        {
  253.            for(i = 1;(i < tam)&&(esCodop)&&(punto>=0&&punto<=1);i++)
  254.            {
  255.                if((!esLetra(codop[i]))&&(codop[i] != '.'))
  256.                   esCodop = 0;
  257.                else if(codop[i] == '.')
  258.                   punto++;
  259.            }
  260.            if(!esCodop)
  261.               printf("\tError:los caracteres validos en un codigo de operacion son letras y el caracter punto\n");
  262.            if(punto > 1)
  263.               printf("\tError:los codigos de operacion no pueden tener mas de un punto\n");
  264.        }
  265.    }
  266. }
  267.  
  268. void ultimaLinea(char *codop)
  269. {
  270.    if((strcmp(codop,"END")) != 0)
  271.       printf("Error:No se encontro el END.\n");
  272. }
  273.  
  274. void listaCodops(COD *cabeza)
  275. {
  276.    int car;
  277.    FILE *hc12;
  278.    char *instruccion,*op;
  279.    COD *ultimo;
  280.    if((hc12 = fopen("TABOP.txt","r"))!= NULL)
  281.    {
  282.        while((car = fgetc(hc12))!= EOF)
  283.        {
  284.            if(car != '\t')
  285.            {
  286.                instruccion = Tabla_Operandos(hc12,INS);
  287.                op = Tabla_Operandos(hc12,OPE);
  288.                if(cabeza == NULL)
  289.                   cabeza = crearNodo(instruccion,op);
  290.                else
  291.                {
  292.                    ultimo = ultimoElemento(cabeza);
  293.                    insertarFinal(instruccion,op,ultimo);
  294.                }
  295.            }
  296.            else
  297.               buscarFinLinea(hc12);
  298.        }
  299.        imprimirLista(cabeza);
  300.    }
  301.    else
  302.       printf("No se pudo abrir el archivo\n");
  303. }
  304.  
  305. char *Tabla_Operandos(FILE *hc12,int tabla)
  306. {
  307.    int car,lon = 0,pos;
  308.    char *cadena;
  309.    fseek(hc12,-1,SEEK_CUR);
  310.    pos = ftell(hc12);
  311.    do
  312.    {
  313.        car = fgetc(hc12);
  314.        lon++;
  315.    }while(car != '\t');
  316.    fseek(hc12,pos,SEEK_SET);
  317.    cadena = malloc(lon+1);
  318.    fgets(cadena,lon+1,hc12);
  319.    quitarSaltosLinea(cadena);
  320.    if(tabla == INS)
  321.       ignorarEspacios(hc12);
  322.    else
  323.       buscarFinLinea(hc12);
  324.    return cadena;
  325. }
  326.  
  327. void insertarFinal(char *instruccion,char *op,COD *ultimo)
  328. {
  329.    ultimo->sig = crearNodo(instruccion,op);
  330.    ultimo->sig->sig = NULL;
  331.    ultimo = ultimo->sig;
  332. }
  333.  
  334. COD *ultimoElemento(COD *cabeza)
  335. {
  336.    COD *ptr;
  337.    ptr = cabeza;
  338.    while(ptr->sig != NULL)
  339.       ptr = ptr->sig;
  340.    return ptr;
  341. }
  342.  
  343. COD *crearNodo(char *instruccion,char *op)
  344. {
  345.    COD *x;
  346.    int tam,tam2;
  347.    tam = strlen(instruccion);
  348.    tam2 = strlen(op);
  349.    x = malloc(sizeof(COD));
  350.    x->codigo = malloc((tam+1));
  351.    x->Operando = malloc((tam2+1));
  352.    strcpy(x->codigo,instruccion);
  353.    strcpy(x->Operando,op);
  354.    x->sig = NULL;
  355.    return x;
  356. }
  357.  
  358. COD *buscarCodop(COD *cabeza,char *codop)
  359. {
  360.    COD *ptr;
  361.    for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
  362.    {
  363.        if((strcmp(ptr->codigo,codop)) == 0)
  364.           return ptr;
  365.    }
  366.    return NULL;
  367. }
  368.  
  369. void imprimirLista(COD *cabeza)
  370. {
  371.    COD *ptr;
  372.    for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
  373.    {
  374.        printf("%s\t",ptr->codigo);
  375.        printf("%s\n",ptr->Operando);
  376.    }
  377. }
  378.  

gracias
En línea

bernii

Desconectado Desconectado

Mensajes: 21


Ver Perfil
Re: problema con lista indexada
« Respuesta #7 en: 8 Enero 2014, 10:25 am »

 :-\Pregunta bruta, para que sirve toda esa programacion ?
En línea

m@o_614


Desconectado Desconectado

Mensajes: 389


Ver Perfil
Re: problema con lista indexada
« Respuesta #8 en: 8 Enero 2014, 19:11 pm »

es un ensamblador, en un archivo de texto me identifica las etiquetas codigos de operacion y operandos, y despues me tiene que buscar el codop en una lista para decirme si lo encontro o no
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Problema de mostrar una lista
Java
Aeros 3 3,056 Último mensaje 10 Agosto 2010, 00:09 am
por Aeros
problema con metodo de lista
Programación C/C++
karmi 2 2,400 Último mensaje 19 Noviembre 2010, 14:31 pm
por Akai
Como encontrar pagina de login ó url no indexada
Hacking
opportunity 1 5,212 Último mensaje 9 Marzo 2011, 13:31 pm
por Ambr0si0
Problema con lista enlazada
Programación C/C++
Lain0x 2 3,636 Último mensaje 8 Julio 2011, 13:20 pm
por Valkyr
problema con una lista
Programación C/C++
m@o_614 1 1,502 Último mensaje 2 Mayo 2014, 06:11 am
por rir3760
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines