Título: por que me aparece el error collect2.exe: error: ld returned 1 exit status Publicado por: SergioeEM en 24 Abril 2018, 19:34 pm Estoy intentando imlementar una lista doblemente ligada y este es mu .c solo que al compilar me sale el error: C:\Users\sergi\AppData\Local\Temp\ccOsiHYv.o:TADListaDL.c:(.text+0x123): undefined reference to `Validate'
collect2.exe: error: ld returned 1 exit status #include <string.h> #include <stdlib.h> #include <stdio.h> #include "TADListaDL.h" //DEFINICI脫N DE FUNCIONES /*************************************************** Operaciones de construcci贸n ***************************************************/ /* void Initialize(lista *l) Descripci贸n: Inicializar lista (Iniciar una lista para su uso) Recibe: lista *l (Referencia a la lista "l" a operar) Devuelve: Una lista Inicializada en 0 Observaciones: El usuario a creado una lista y l tiene la referencia a ella, si esto no ha pasado se ocasionara un error. */ void Initialize (lista *l) { l->frente=NULL; l->final=NULL; l->tamanio=0; return; } /* void Destroy(lista *l) Descripci贸n: Destruir una lista (Recibe una lista l y la libera completamente) Recibe: lista *l (Referencia a la lista "l" a operar) Devuelve: Observaciones: El usuario a creado una lista y l tiene la referencia a ella, si esto no ha pasado se ocasionara un error. */ void Destroy (lista *l) { //Apuntador auxiliar a nodo nodo *aux; //Mientras el apuntador del frente de la lista no sea "NULL" while(l->frente != NULL) { //Guardar la referencia el frente aux = l->frente; //El nuevo frente es el siguiente l->frente = l->frente->siguiente; //Liberar el antiguo frente de memoria free(aux); } //Colocar el final inicializado en "NULL" l->final = NULL; l->tamanio = 0; return; } /*************************************************** Operaciones de posicionamiento y busqueda ***************************************************/ /* posicion Final(lista *l) Descripci贸n: Recibe una lista l y regresa la posici贸n del final (Recibe una lista l y retorna la posici贸n del elemento al final de esta.) Recibe: lista *l (Referencia a la lista "l" a operar) Devuelve: posici贸n del nodo que contiene al elemeto final de la lista Observaciones: El usuario a creado una lista y l tiene la referencia a ella, si esto no ha pasado se ocasionara un error. */ posicion Final (lista *l) { return l->final; } /* posicion First(lista *l) Descripci贸n: Recibe una lista l y regresa la posici贸n del frente (Recibe una lista l y retorna la posici贸n del elemento al frente de esta.) Recibe: lista *l (Referencia a la lista "l" a operar) Devuelve: posici贸n del nodo que contiene al elemento del frente de la lista Observaciones: El usuario a creado una lista y l tiene la referencia a ella, si esto no ha pasado se ocasionara un error. */ posicion First (lista *l) { return l->frente; } /* posicion Following(lista *l, posicion p) Descripci贸n: Recibe una lista l, una posici贸n p y devuelve la posici贸n del elemento siguiente de p Recibe: lista *l y posicion p (Referencia a la lista "l" a operar y posici贸n valida de la lista) Devuelve: posici贸n del nodo siguiente a la posicion dada Observaciones: El usuario a creado una lista y l tiene la referencia a ella, p es una posicion valida de la lista, si esto no ha pasado se ocasionara un error. */ posicion Following (lista *l,posicion p) { posicion aux; if(ValidatePosition(l,p)) { aux=p->siguiente; return aux; } else { printf("ERROR: Funcion Following (p es invalida), destruire tu pila por noob"); exit(1); } } /* posicion Previous(lista *l, posicion p) Descripci贸n: Recibe una lista L, una posici贸n P y devuelve la posici贸n del elemento anterior de P Recibe: lista *l y posicion p (Referencia a la lista "l" a operar y posici贸n valida de la lista) Devuelve: posici贸n del nodo anterior a la posicion dada Observaciones: El usuario a creado una lista y l tiene la referencia a ella, p es una posicion valida de la lista, si esto no ha pasado se ocasionara un error. */ posicion Previous (lista *l,posicion p) { posicion aux; if (Validate(l,p)) { aux=p->atras; return aux; } else { printf("ERROR: Funcion Previous (p es invalida), destruire tu pila por noob"); exit(1); } } /* posicion Search(lista *l, elemento e) Descripci贸n: Recibe una lista l y un elemento e, regresa la posici贸n que coincida exactamente con el elemento e. Recibe: lista *l y un elemento e (Referencia a la lista "l" a operar y elemento a buscar en la lista) Devuelve: posici贸n del elemento en caso de ser encontrado, si no se encuentra se devuelve una posicion invalida Observaciones: El usuario a creado una lista y l tiene la referencia a ella el elemento a buscar se compara directamente a nivel de bytes. */ posicion Search (lista *l,elemento e) { posicion aux=l->frente; while(aux!=NULL) { if(memcmp(&aux->e,&e,sizeof(elemento))==0) { return aux; } aux=aux->siguiente; } return NULL; } /*************************************************** Operaci贸nes de consulta /***************************************************/ /* elemento Position(lista *l, posicion p) Descripci贸n: Recibe una lista l, una posici贸n p y devuelve el elemento en dicha posici贸n. Recibe: lista *l y una posicion p(Referencia a la lista "l" a operar posicion valida en la lista) Devuelve: Elemento en la posicion dada, si la posicion es invalida se genera error. Observaciones: La lista l es no vac铆a y la posici贸n p es una posici贸n valida. */ elemento Position (lista *l,posicion p) { elemento e; if(ValidatePosition(l,p)) return p->e; else { printf("\nERROR Position(): La posicion es invalida"); exit(1); } } /* boolean ValidatePosition(lista *l, posicion p) Descripci贸n: Recibe una lista l, una posici贸n p y devuelve TRUE si la posici贸n es una posici贸n p valida en la lista l y FALSE en caso contrario. Recibe: lista *l y una posicion p(Referencia a la lista "l" a operar y una posicion) Devuelve: Booleano Observaciones: */ boolean ValidatePosition (lista *l,posicion p) { posicion aux; aux=l->frente; while(aux!=NULL) { if(aux==p) //************** return TRUE; aux=aux->siguiente; } return FALSE; } /* elemento Element(lista *l, int n) Descripci贸n: Recibe una lista y un 铆ndice (entre 1 y el tama帽o de la lista) y devuelve el elemento que se encuentra en la lista en ese 铆ndice partiendo del frente de este =1 hacia atr谩s. Recibe: lista *l y una entero Devuelve: elemento Observaciones: Si la cola esta vac铆a o el 铆ndice se encuentra fuera del tama帽o de la lista se produce error. */ elemento Element(lista *l, int n) { elemento r; nodo *aux; int i; //Si el elemento solicitado esta entre 1 y el tama帽o de la lista if (n>0&&n<=Size(l)) { //Obtener el elemento en la posici贸n n aux=l->frente; for(i=2;i<=n;i++) aux=Previous(l,aux); r=aux->e; } else { printf("\nERROR (Element): Se intenta acceder a elemento %d inexistente",n); exit(1); } return r; } /* posicion ElementPosition(lista *l, int n) Descripci贸n: Recibe una lista y un 铆ndice (entre 1 y el tama帽o de la lista) y devuelve la posicion del elemento que se encuentra en la lista en ese 铆ndice partiendo del frente de este =1 hacia atr谩s. Recibe: lista *l y una entero Devuelve: posicion Observaciones: Si la cola esta vac铆a o el 铆ndice se encuentra fuera del tama帽o de la lista se produce error. */ posicion ElementPosition(lista *l, int n) { posicion aux=NULL; int i; //Si el elemento solicitado esta entre 1 y el tama帽o de la lista if (n>0&&n<=Size(l)) { //Obtener el elemento en la posici贸n n aux=l->frente; for(i=2;i<=n;i++) aux=Previous(l,aux); } return aux; } /* int Size(lista * l); Descripci贸n: Recibe una lista y devuelve el n煤mero de elemento que se encuentran en esta. Recibe: lista *l (Referencia a la lista "l") Devuelve: int (Tama帽o de la lista) Observaciones: El usuario a creado una lista,la lista fue correctamente inicializada. */ int Size (lista *l) { return l->tamanio; } /* int Size(lista * l); Descripci贸n: Recibe una lista l y devuelve TRUE en caso de que la lista este vac铆a y FALSE en caso contrario. Recibe: lista *l (Referencia a la lista "l") Devuelve: boolean (TRUE o FALSE) Observaciones: El usuario a creado una lista,la lista fue correctamente inicializada. */ boolean Empty (lista *l) { return (l->tamanio==0) ? TRUE:FALSE; } /*************************************************** Operaciones de modificaci贸n ****************************************************/ /* void Insert (lista * l, posicion p, elemento e, boolean b); Descripci贸n: Inserta un elemento e en la lista este deber谩 agregarse al frente de p si b es verdadero y atr谩s de p en caso contrario. Si p es invalida Recibe: lista *l (Referencia a la lista "l"), posici贸n p (Posici贸n valida o invalida en la lista), elemento e (Elemento a insertar en la lita), boolean b (Indicador de inserci贸n antes de p=TRUE o despues de p =FALSE) Devuelve: Observaciones: El usuario a creado una lista,la lista fue correctamente inicializada, si P es no valida o NULL, se insertar谩 a e al frente de la lista. */ void Insert (lista * l, posicion p, elemento e, boolean b) { nodo *aux,*aux2; //posicion aux; posicion q; //Crear el nodo e insertar e aux=malloc(sizeof(nodo)); //Si no se puede reservar memoria para el nuevo nodo (ERROR de lista) if(aux==NULL) { printf("\nERROR (Insert): No se puede crear un nuevo nodo"); exit(1); } //Introducir a e en el nuevo nodo aux->e=e; //Validamos la posicion p if(!ValidatePosition(l,p)) {//Si es invalida insertar al frente de la lista if(l->final!=NULL) //Si la lista no esta vacia { aux->siguiente=l->frente; q=ElementPosition(l,1); l->frente=aux; aux->atras=NULL; aux->siguiente=q; } else//Si esta vacia { aux->siguiente=l->frente; l->frente=aux; l->final=aux; aux->atras=NULL; } } else {//Si p es valida //Si p es FALSE deber谩 agregarse despues de la posicion p if(b==FALSE) { //Si p no es e final if(p!=l->final) { aux->siguiente=p->siguiente; q=Following(l,p); p->siguiente=aux; aux->atras=p; q->atras=aux; } else //Si p es el final { aux->siguiente=p->siguiente; p->siguiente=aux; l->final=aux; aux->atras=p; } } else {//Si p es TRUE deber谩 agregarse antes de la posicion p aux2=Previous(l,p); //Si aux2 no existe (p es el frente) if(aux2==NULL) { aux->siguiente=l->frente; l->frente=aux; aux->atras=NULL; p->atras=aux; } //Insertar despues de aux2 else { aux2->siguiente=aux; aux->siguiente=p; p->atras=aux; aux->atras=aux2; } } } //Aumentar el tamanio de la lista l->tamanio++; return; } /* void Add (lista *l,elemento e); Descripci贸n: Recibe una lista l y un elemento e, se agrega a e al final de la lista l. Recibe: lista *l (Referencia a la lista "l"), elemento e (Elemento a insertar en la lita) Devuelve: Observaciones: El usuario a creado una lista,la lista fue correctamente inicializada. */ void Add (lista *l,elemento e) { posicion aux; aux=malloc(sizeof(nodo)); //Si no se puede reservar memoria para el nuevo nodo (ERROR de lista) if(aux==NULL) { printf("\nERROR (Add): No se puede crear un nuevo nodo"); exit(1); } //Agregar el elemento al nodo aux->e=e; //Si la lista esta vacia if(l->final==NULL&&l->frente==NULL&&l->tamanio==0) { aux->siguiente=NULL; l->frente=aux; l->final=aux; aux->atras=NULL; } //Si la lista no esta vacia else { l->final->siguiente=aux; aux->siguiente=NULL; aux->atras=l->final; l->final=aux; } //Incrementar el tamaniode la lista l->tamanio++; return; } /* void Remove (lista *l,posicion p); Descripci贸n: Recibe una lista l y una posici贸n p, el elemento en la posici贸n p ser谩 removido. Recibe: lista *l (Referencia a la lista "l"), posicion p (posicion a eliminar en la lista) Devuelve: Observaciones: El usuario a creado una lista,la lista fue correctamente inicializada, la posicion p es valida. */ void Remove (lista *l,posicion p) { posicion aux; //Si p es valida if(ValidatePosition(l,p)) { //Si la p es frente y final (Solo hay uno en la lista) if(p==l->final&&p==l->frente) { free(p); l->final=NULL; l->frente=NULL; l->tamanio=0; } //Si la p es el final else if(p==l->final) { aux=Previous(l,p); aux->siguiente=NULL; l->final=aux; l->tamanio--; free(p); } //Si la p es el frente else if(p==l->frente) { l->frente=l->frente->siguiente; //l->frente=p->siguiente; l->frente->atras=NULL; free(p); l->tamanio--; } else//Si p esta en medio { aux=Previous(l,p); aux->siguiente=p->siguiente; aux=Following(l,p); aux->atras=p->atras; free(p); l->tamanio--; } } else { printf("\nERROR: Remove p es invalida"); exit(1); } return; } /* void Replace (lista *l,posicion p, elemento e); Descripci贸n: Recibe una lista l, una posici贸n p y un elemento e, el elemento en la posici贸n p ser谩 sustituido por e Recibe: lista *l (Referencia a la lista "l"), posicion p (posicion a remplazar en la lista), elemento e (elemento que remplazara al existente en p) Devuelve: Observaciones: El usuario a creado una lista,la lista fue correctamente inicializada, la posicion p es valida. */ void Replace (lista *l,posicion p, elemento e) { //Si la posicion p existe if(ValidatePosition(l,p)) { p->e=e; //Remplazar a e } else { printf("\nERROR: Replace : No se puede remplazar una posicion invalida"); exit(1); } return; } /******************************************************************************** //Funci贸n para usarse en depuraci贸n, la cu谩l imprime las direcciones de //memoria de los nodos, su apuntador a siguiente y hacia atras ********************************************************************************/ void VerLigasLista(lista *l) { posicion aux; aux=l->frente; printf("\n*************************************************************"); while(aux!=NULL) { printf("\nPosicion=%p\tSiguiente=%p",aux,aux->siguiente); aux=aux->siguiente; printf("\nPosicion=%p\tSiguiente=%p",aux,aux->siguiente); aux=aux->atras; } printf("\n*************************************************************"); return; } |