Varias personas me pidieron el exámen. No tengo la copia, imposible conseguirla Jaja
Antes que me olvide dejo escrito que fue lo que tomaron. Les adelanto que no hubo teoría, nada de nada.
Fue un ejercicio práctico de listas básicamente (doblemente enlazada, por supuesto).

Estaba basado en una situción real, una empresa que hacía tal cosa (en este momento no me acuerdo qué), supongamos que procesaba las señales de una radio (?)

El enunciado comenzaba dandote una función (ya hecha por un ingeniero) la cuál se encargaba de interpretar funciones. Esas funciones estaban incluídas dentro de los nodos de una lista junto a una variable que representaba el identificador de dicha función (pero no es de importancia por ahora, lo definiré más adelante). Volviendo a lo dicho anteriormente, el prototipo de la función que interpreta inputs es:

 struct sData* transalate (char *);

No es de importancia lo que contiene esa estructura.
Para trabajar más cómodo y no tener que tipear siempre lo mismo nos daba definido lo siguiente:

 typedef struct sData* (*tranlatef_t)(*char) //Puntero a función.

También estaba definida una estructura con los punteros que apuntan al siguiente y anterior nodo del que estamos ubicados. Así como también la función (translate) y el identificador (id).

 struct Adapter{

char *id;

transaltef_t translate;

struct Adapter next;

struct Adapter prev;

}adapter_t;

Nos pedía realizar las funciones para manejar una lista doblemente enlazada.

Las funciones a realizar eran:

 int insert_adpter (adapter_t **list, char *id, translatef_t translate);

Debíamos hacer en esta función un código que permita ingresar una nueva función con su respectivo identificador (fijensé que están dados como parámetros). Retornaría 0 si la operación fue exitosa o cualquier otro número en caso de error.

 transalef_t find_adapter (adapter_t *list, char *id);

Nos daba un identificador, y teníamos que buscar la función que contenga dicho id. Retorna la función o NULL en caso que no exista ese nodo ó si la lista está vacía.

 struct sData* find_adapter (adapter_t *list, char *id, char* input);

Pedía lo mismo que la función anterior pero esta vez en lugar de retornar la función había que retornar lo que interpretó la función transalte (declarada al comienzo de este topic) pasándole como parámetro input.


También había un par de puntos extra con los que podías aumentar la nota. Algunos de ellos:
-Ordenar la lista.
-Algo relacionado con mayúsculas y minúsculas.
-Comprobación de errores.
-Crear header y decir línea de compilación.


Si hay algún problema lo resuelvo.

Saludos!

Hola, si tenes tiempo resolvelo
Exitos jJAJA

---

Graaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaacias

Acá va la resolución:

 //Función que inserta un nuevo nodo en la lista.

int insert_adpter (adapter_t **list, char *id, translatef_t translate)

{

   adapter_t *Nuevo; //El nodo a insertar.



   //Reservo memoria.

   Nuevo=(adapter_t *)malloc(sizeof(adapter));



   if (Nuevo==NULL)

   {

      printf ("\n Fallo al asignar memoria.\n");

      return -1; //Retorna algo distinto a 0 por error en la asignación de memoria.

   }

  

   //Inserto los campos en el nodo nuevo.

   Nuevo->translate=translate;

   Nuevo->id=id;



   //Doble enlace.

   Nuevo->next=*list;

   if (*list!=NULL) //Si la lista no está vacía...

      (*list)->prev=Nuevo;

   *list=Nuevo;



   return 0; //Operación exitosa.

}



//Función que busca un nodo a partir de la id.

translatef_t find_adapter (adapter_t *list, char *id)

{

   translatef_t funcion;



   if (list==NULL)

   {

      printf ("\n Lista vacía.\n");

      return NULL; //No se encontró el nodo pues la lista está vacía.

   }



   while ( list!=NULL && (strcmp(id,list->id))!=0 )

      list=list->next; //Recorre la lista nodo por nodo.



   funcion=list->translate;



   return funcion; //Retorna la función (translate) del nodo buscado.

}



//Idem función anterior, excepto que esta vez devuelvo lo interpretado por la función translate.

struct sData* find_adapter (adapter_t *list, char *id, char* input)

{

   struct sData *P;

   translatef_t translat;



   translat = find_adapter (list,id); //Utilizo la función que creé anteriormente.



   translat=translate;



   P=translat(input);



   return P;

} 

   

translat = find_adapter (list,id); //Utilizo la función que creé anteriormente.

translat=translate;
P=translat(input);

Encontras el dato y lo guardas en translat... y después?

struct sData* transalate (char *);

Ese es un puntero a función...
No estas pisando el dato?

Uhu, gracias por subirlo!
Ahora estoy re quemado, pero cuando tenga tiempo lo miro bien