Foro de elhacker.net

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

typedef struct nodo
{
    char *codigo;
    int indice = 0;
    struct nodo *sig;
}NODO;

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

gracias

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

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

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

typedef struct nodo
{
    char *codigo;
    struct nodo *sig;
}CODOP;
 
void buscarCodop(CODOP *cabeza)
{
    CODOP *ptr;
    char *codop = "BLE";
    int encontrado = 0;
    for(ptr = cabeza;(ptr != NULL)&&(encontrado);ptr = ptr->sig)
    {
        if((strcmp(ptr->codigo,codop)) == 0)
           encontrado = 1;
    }
    if(encontrado == 0)
       printf("\nNO SE ENCONTRO EL CODOP DE OPERACION\n");
    else
       printf("\nNO SE ENCONTRO EL CODOP DE OPERACION\n");
}
 

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

gracias

¡Buenas!

Tienes un error aquí:

    int encontrado = 0;
   for(ptr = cabeza;(ptr != NULL)&&(encontrado);ptr = ptr->sig)
 

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!

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:

#include <stdio.h>
#include <string.h>
 
typedef struct nodo
{
   char *codigo;
   struct nodo *sig;
} CODOP;
 
void buscarCodop(CODOP *p)
{
   while (p != NULL && strcmp(p->codigo, "BLE") != 0)
      p = p->sig;
 
   if (p)
      puts("Se encontro el codop");
   else
      puts("No se encontro el codop");
}

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

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

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define LONG_ETIQUETA 8
#define LONG_CODOP 5
#define COMENTARIO ';'
#define TABULADOR '\t'
#define ESPACIOS_ ' '
 
typedef enum {FALSO,VERDADERO} booleano;
typedef enum {ETIQUETA,CODOP,OPERANDO} linea;
typedef enum {INS,OPE} tabla;
 
typedef struct nodo
{
    char *codigo;
    char *Operando;
    struct nodo *sig;
}COD;
 
COD *crearNodo(char *instruccion,char *op);
void insertarFinal(char *instruccion,char *op,COD *ultimo);
COD *ultimoElemento(COD *cabeza);
void quitarSaltosLinea(char *cadena);
int verificarCombinacion(FILE *fd);
booleano esComentario(FILE *fd);
char *Etiqueta_Codop_Operando(FILE *fd,int linea);
char *_Codop_Operando(FILE *fd,int linea);
void ultimaLinea(char *codop);
void erroresEtiqueta(char *etiqueta);
void erroresCodop(char *codop);
void buscarFinLinea(FILE *fd);
void ignorarEspacios(FILE *fd);
booleano esNumero(char caracter);
booleano esLetra(char caracter);
void listaCodops(COD *cabeza);
char *Tabla_Operandos(FILE *hc12,int tabla);
COD *buscarCodop(COD *cabeza,char *codop);
void imprimirLista(COD *cabeza);
 
int main()
{
    FILE *fd;
    int car,combinacion;
    COD *cabeza = NULL,*encontrado;
    char *etiqueta,*codop,*operando;
    //listaCodops(cabeza);
    if((fd = fopen("P2ASM.txt","r"))!= NULL)
    {
        while((car = fgetc(fd))!= EOF)
        {
            switch(car)
            {
                case COMENTARIO:
                   if(esComentario(fd))
                      printf("COMENTARIO\n\n");
                   else
                      buscarFinLinea(fd);
                   break;
                case ESPACIOS_:
                case TABULADOR:
                   etiqueta = "null";
                   printf("ETIQUETA = %s\n",etiqueta);
                   ignorarEspacios(fd);
                   codop = Etiqueta_Codop_Operando(fd,CODOP);
                   printf("CODOP = %s\n",codop);
                   erroresCodop(codop);
                   if((encontrado = buscarCodop(cabeza,codop)) == NULL)
                      printf("\tNO SE ENCONTRO EL CODOP DE OPERACION\n");
                   combinacion = verificarCombinacion(fd);
                   if(combinacion == 2)
                   {
                       operando = "null";
                       printf("OPERANDO = %s\n\n",operando);
                   }
                   else
                   {
                       ignorarEspacios(fd);
                       operando = Etiqueta_Codop_Operando(fd,OPERANDO);
                       printf("OPERANDO = %s\n\n",operando);
                   }
                   break;
                default:
                   etiqueta = Etiqueta_Codop_Operando(fd,ETIQUETA);
                   printf("ETIQUETA = %s\n",etiqueta);
                   erroresEtiqueta(etiqueta);
                   combinacion = verificarCombinacion(fd);
                   if(combinacion == 2)
                   {
                       codop = "null";
                       printf("CODOP = %s\n",codop);
                       erroresCodop(codop);
                       if((encontrado = buscarCodop(cabeza,codop)) == NULL)
                          printf("\tNO SE ENCONTRO EL CODOP DE OPERACION\n");
                       operando = "null";
                       printf("OPERANDO = %s\n\n",operando);
                   }
                   else
                   {
                       ignorarEspacios(fd);
                       codop = Etiqueta_Codop_Operando(fd,CODOP);
                       printf("CODOP = %s\n",codop);
                       erroresCodop(codop);
                       if((encontrado = buscarCodop(cabeza,codop)) == NULL)
                          printf("\tNO SE ENCONTRO EL CODOP DE OPERACION\n");
                       combinacion = verificarCombinacion(fd);
                       if(combinacion == 2)
                       {
                           operando = "null";
                           printf("OPERANDO = %s\n\n",operando);
                       }
                       else
                       {
                           ignorarEspacios(fd);
                           operando = Etiqueta_Codop_Operando(fd,OPERANDO);
                           printf("OPERANDO = %s\n\n",operando);
                       }
                   }
                   break;
            }
        }
        ultimaLinea(codop);
    }
    else
       printf("No se pudo abrir el archivo");
    return 0;
}
 
booleano esComentario(FILE *fd)
{
    int car;
    while((car = fgetc(fd))!= '\n')
    {
        if(car == ';')
           return 0;
    }
    return 1;
}
 
void buscarFinLinea(FILE *fd)
{
    int car;
    while((car = fgetc(fd))!= '\n')
        ;
}
 
void ignorarEspacios(FILE *fd)
{
    int car;
    do
    {
        car = fgetc(fd);
    }while(car == '\t' || car == ' ');
}
 
int verificarCombinacion(FILE *fd)
{
    int car,combinacion;
    fseek(fd,-1,SEEK_CUR);
    if((car = fgetc(fd))== '\n')
       combinacion = 2;
    else
       combinacion = 1;
    return combinacion;
}
 
booleano esLetra(char caracter)
{
    if((caracter >= 'A' && caracter <= 'Z')||(caracter >= 'a' && caracter <= 'z'))
       return 1;
    else
       return 0;
}
 
booleano esNumero(char caracter)
{
    if(caracter >= '0' && caracter <= '9')
       return 1;
    else
       return 0;
}
 
char *Etiqueta_Codop_Operando(FILE *fd,int linea)
{
    int car,lon = 0,pos;
    char *cadena;
    fseek(fd,-1,SEEK_CUR);
    pos = ftell(fd);
    if((linea == ETIQUETA)||(linea == CODOP))
    {
        do
        {
            car = fgetc(fd);
            lon++;
        }while(car != '\t' && car != ' ' && car != '\n');
    }
    else
    {
        do
        {
            car = fgetc(fd);
            lon++;
        }while(car != '\n');
    }
    cadena = calloc(lon+1);
    fseek(fd,pos,SEEK_SET);
    fgets(cadena,lon+1,fd);
    quitarSaltosLinea(cadena);
    return cadena;
}
 
void quitarSaltosLinea(char *cadena)
{
    char *ptr;
    if(((ptr=strchr(cadena,'\n'))!=NULL)||((ptr=strchr(cadena,'\t'))!=NULL)||((ptr=strchr(cadena,' '))!=NULL))
       *ptr = '\0';
}
 
void erroresEtiqueta(char *etiqueta)
{
    int tam,i = 0,esEtiqueta = 1;
    tam = strlen(etiqueta);
    if(tam-1 > LONG_ETIQUETA)
       printf("\tError:la longitud maxima de una etiqueta es de 8 caracteres\n");
    if(!esLetra(etiqueta[i]))
       printf("\tError:la etiqueta debe iniciar con letra\n");
    else
    {
        for(i = 0;(i < tam)&&(esEtiqueta);i++)
        {
           if((!esLetra(etiqueta[i]))&&(!esNumero(etiqueta[i]))&&(etiqueta[i] != '_'))
              esEtiqueta = 0;
        }
        if(!esEtiqueta)
           printf("\tError:los caracteres validos en las etiquetas son letras, digitos(0..9) y el guion bajo\n");
    }
}
 
void erroresCodop(char *codop)
{
    int tam,i = 0,esCodop = 1,punto = 0;
    tam = strlen(codop);
    if(tam > LONG_CODOP)
       printf("\tError:la longitud maxima de un codigo de operacion es de 5 caracteres\n");
    if((strcmp(codop,"null"))== 0)
       printf("\tError:siempre debe de haber un codigo de operacion\n");
    else
    {
        if(!esLetra(codop[i]))
        printf("\tError:los codigos de operacion deben iniciar con letra\n");
        else
        {
            for(i = 1;(i < tam)&&(esCodop)&&(punto>=0&&punto<=1);i++)
            {
                if((!esLetra(codop[i]))&&(codop[i] != '.'))
                   esCodop = 0;
                else if(codop[i] == '.')
                   punto++;
            }
            if(!esCodop)
               printf("\tError:los caracteres validos en un codigo de operacion son letras y el caracter punto\n");
            if(punto > 1)
               printf("\tError:los codigos de operacion no pueden tener mas de un punto\n");
        }
    }
}
 
void ultimaLinea(char *codop)
{
    if((strcmp(codop,"END")) != 0)
       printf("Error:No se encontro el END.\n");
}
 
void listaCodops(COD *cabeza)
{
    int car;
    FILE *hc12;
    char *instruccion,*op;
    COD *ultimo;
    if((hc12 = fopen("TABOP.txt","r"))!= NULL)
    {
        while((car = fgetc(hc12))!= EOF)
        {
            if(car != '\t')
            {
                instruccion = Tabla_Operandos(hc12,INS);
                op = Tabla_Operandos(hc12,OPE);
                if(cabeza == NULL)
                   cabeza = crearNodo(instruccion,op);
                else
                {
                    ultimo = ultimoElemento(cabeza);
                    insertarFinal(instruccion,op,ultimo);
                }
            }
            else
               buscarFinLinea(hc12);
        }
        imprimirLista(cabeza);
    }
    else
       printf("No se pudo abrir el archivo\n");
}
 
char *Tabla_Operandos(FILE *hc12,int tabla)
{
    int car,lon = 0,pos;
    char *cadena;
    fseek(hc12,-1,SEEK_CUR);
    pos = ftell(hc12);
    do
    {
        car = fgetc(hc12);
        lon++;
    }while(car != '\t');
    fseek(hc12,pos,SEEK_SET);
    cadena = malloc(lon+1);
    fgets(cadena,lon+1,hc12);
    quitarSaltosLinea(cadena);
    if(tabla == INS)
       ignorarEspacios(hc12);
    else
       buscarFinLinea(hc12);
    return cadena;
}
 
void insertarFinal(char *instruccion,char *op,COD *ultimo)
{
    ultimo->sig = crearNodo(instruccion,op);
    ultimo->sig->sig = NULL;
    ultimo = ultimo->sig;
}
 
COD *ultimoElemento(COD *cabeza)
{
    COD *ptr;
    ptr = cabeza;
    while(ptr->sig != NULL)
       ptr = ptr->sig;
    return ptr;
}
 
COD *crearNodo(char *instruccion,char *op)
{
    COD *x;
    int tam,tam2;
    tam = strlen(instruccion);
    tam2 = strlen(op);
    x = malloc(sizeof(COD));
    x->codigo = malloc((tam+1));
    x->Operando = malloc((tam2+1));
    strcpy(x->codigo,instruccion);
    strcpy(x->Operando,op);
    x->sig = NULL;
    return x;
}
 
COD *buscarCodop(COD *cabeza,char *codop)
{
    COD *ptr;
    for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
    {
        if((strcmp(ptr->codigo,codop)) == 0)
           return ptr;
    }
    return NULL;
}
 
void imprimirLista(COD *cabeza)
{
    COD *ptr;
    for(ptr = cabeza;ptr != NULL;ptr = ptr->sig)
    {
        printf("%s\t",ptr->codigo);
        printf("%s\n",ptr->Operando);
    }
}
 

gracias

 :-\Pregunta bruta, para que sirve toda esa programacion ?

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