¡Buenas!

No se que ves de extraño en la declaracion de los tipos. Una cola tiene un punto de entrada y uno de salida, que es lo que se ha agrupado en el struct Cola. Pero esto lo puedes hacer como quieras, siempre y cuando puedas saber donde esta el principio, para sacar datos, y donde el final, para introducirlos.

¡Saludos!

Yo creo que lo que quiso hacer tu profesor es lo siguiente (tengo muy poca experiencia en listas enlazadas, sé la lógica, pero muchos conceptos los ignoro):

struct Componente {
 int dato;
 struct Componetne  *sig;
};
 

Hasta ahí, lo que entiendo es que declara el elementeo básica de una lista enlazada: una estructura que tiene un dato y un puntero hacia una estructura de éste mismo tipo (hasta ahí el único error está en el ";" que pongo luego de "struct Componetne  *sig" y el que agrego al final)

Luego hace esto:

typedef Componente *Puntero;
 

Lo cual (o por lo menos con lo poco que sé de C) es incorrecto, porque trata de crear un nuevo tipo llamado "*Puntero" que sea igual al tipo "Componente" (el cuál no existe, existe "struct Componente")

El quiso hacer (en mi opinión)

typedef struct Componente* Puntero;
 

De modo que ahí creaba un nuevo tipo llamado Puntero, que consistía en un puntero a una estructura tipo Componente.
Creo que eso es lo que quisiste poner con:
Ahora lo que haces tú es:

typedef struct Componente Puntero;
 

Ahí como bien dices:
Y ahora te respondo la pregunta:Bueno, creo que te la contestaste solito:

Lo que, como bien dices, haces con tu código es crear un tipo llamado Puntero que es lo mismo que struct Componente. Osea, con lo tuyo sería lo mismo hacer:

struct Componente a;
//o hacer:
Puntero a;
 

En vez si quieres q "a" sea un puntero a una estructura componente debes hacer (para tu caso):

struct Componente *a;
//o hacer:
Puntero *a;
 

Ya que en tu caso, te vuelvo a repetir struct Componente vendría a ser lo mismo que Puntero...

Aún así, creo que ya que el tipo de variable que estás definiendo se llama "Puntero" sería mejor que sea un puntero, no?

Pués entonces habría que hacer lo que hice yo arriba (y creo que eso quiso hacer tu profesor)

typedef struct Componente* Puntero;
 

Bueno aquí un ejemplo del uso del mismo:

struct Componente a;
Puntero b;
a.dato=7;
b=&a;
b->dato=33
 

De modo que "a" es una estructura Componente y b un puntero a estructura Componente que luego le asignamos la dirección de "a" y modificamos el contenido de ésta variable a través de "b"...

Luego puedes hacer:

struct Cola { Puntero principio, final; };

Ahi declaras otro tipo de estructura (la estructura Cola) que posee dentro de sí un dos punteros a estructuras Componente.
Sé lo que haces pero no se bien para que la utilizas... necesitaría el código, como te dije tengo muy poca experiencia en ésto de las listas enlazadas y no sé que es una cola, pero tengo claro lo que hiciste ahí... Pero supongo que te viene mejor que sea una estructura con dos punteros a estructuras componentes que una estructura con dos estructuras componentes adentro. Ya que de este modo, podés cambiar el principio y el final (haciendo que dichos punteros apunten a otras estructuras)...

Y la verdad que no entiendo tus problemas sin una explicación un poco más detallada y menos confusa... además del código....


Espero aver ayudado y no haber liado más el asunto...

Pués bien, mis hipótesis se confirman... La estructura Cola (en tu código la llamas nodcola), que contiene dos punteros hacia estructuras Componentes, es para manejar la lista, teniendo siempre una referencia al principio y al final de la cadena...

Creí eso, pero no quise preguntarte para no liarte tanto. Porque... para qué quieres declarar el tipo de estructura Cola, si sólo necesitas una variable de ese tipo? Bah, yo creo que si vas a declarar una estructura (una plantilla como tu creo que llamas) es para declarar luego más de una sola variable de ese tipo. Pero en éste caso solo necesitas una variable, para poder almacenar el principio y el final de la lista...
Espero que te quede más claro con esto:

Si haces esto:

struct nodcola {Puntero principio, final};
 

Estás definiendo un nuevo tipo (struct nodcola). Cualquier varible que definas de éste tipo, poseerán dos punteros hacia estructuras Componente.
Así luego podemos hacer:

struct nodcola a,b;
struct componente x,y,z;
x.next=&y;
y.next=&z;
z.next=NULL;
a.principio=&x;
a.final=&z;
/* Para qué necesito la variable b (de tipo nodcola)
    si me basta con a, para tener una referencia del
    principio y del final de la lista enlazada...
*/
 

En todo caso podés hacer esto:

struct {Puntero principio, final} Cola;
 

Y ahí estás declarando una variable Cola que contiene en sí dos punteros Cola.principio y Cola.final con los cuales podes apuntar al principio y al final de la lista haciendo algo como:

Cola.principio=&x;
Cola.final=&z
 

Osea, no declaras el tipo "struct nodcola" ya que sólo necesitas UNA variable de ese tipo...

Bueno, éstas fueron aclaraciones tontas, que de verdad no hacen al funcionamiento del programa... Ahora sí unas aclaraciones serias sobre lo que dices y sobre tu código...


-
La verdad que no sé como solucionas problemas si no tenés idea clara de como lo estás haciendo, a menos que hagas como muchos alumnos míos que ponen las cosas de diferentes maneras hasta que les compile o funcione...
Un consejo: trata de entender cada cosa que hagas... cada línea que escribas, que sepas certeramente lo que en verdad estás haciendo... Si no la tienes muy claras puedes crear un programa de prueba, en donde probar la parte en cuestión sobre la que tienes dudas y ver como funciona...


-Para poder modificar las variables dentro de las funciones las pasas por referencia. En tu caso pasas un puntero a dichas variables... Pero tu siempre trabajas con la variable apuntada por dicho puntero... Aver si me explico...
Si hago:

Puntero *first;

first es un puntero a un puntero a una estructura componente...
pero tu siempre trabajas con (*first) porque lo que te interesa es el puntero a la estructura componente, no el puntero a este puntero...
Puedes hacer más claro el código si utilizas las variables pasadas por referencia del siguiente modo:

int add_nod(Puntero &first,Puntero &ultimo,int dato)
 

Mirate esto: http://www.mailxmail.com/curso-programacion-c/parametros-valor-referencia


-Tratá de no usar variables globales inecesarias, es cierto que es cómodo que los punteros que tienen la referencia del principio y el final de la lista sean globales, pero para códigos más largos puede llegar a causar confusiones...
En verdad creo que sí algún aspecto positivo tiene declarar el tipo strcut nodcola es que puedes hacer que el retorno de una función sea de dicho tipo y así no tener que usar variables globales ni referencias...


-Te explico el funcionamiento de malloc, porque creo que la utilizas mal
Si yo quiero declarar N variables tipo int hago lo siguiente:

int* puntero;
puntero = (int *) malloc (N*sizeof(int));
 

El argumento indica el tamño del espacio reservado... lo que tu haces es como si yo hiciese acá:

int* puntero;
puntero ( (int *) malloc (N*sizeof(int*));
 

Espero que entiendas lo que tienes que modificar, no pretendas que te lo dé servido...


-En la función ext_nod cuando haces:

if(*first == NULL)
      ultimo = NULL;
 

No estás modificando el valor de Cola.final, sino que estás modificando el puntero que apunta a esta variable... tendrías que modifcar (*ultimo)...


-No sé que es lo que se te pide, pero si la función add_nod crea más nodos al final de la lista, sería más lófico que ext_nod extraiga nodos del final de la cola en vez desde el principio no?


-Utiliza las etiquetas GeSHi para que el código sea más claro...


-Dices que: Pero en tu código si utilizas dicha estructura... (osea, declaras variables de dicho tipo)... Supongo que en el código donde no la usabas declarabas directamente:

Puntero principio, final;
 

-Tan preocupado estás por el código de un exámen? y te acuerdas del código perfectamente de dicho exámen? Espero que ésto no sea una tarea, pués sería contrario a las reglas del foro... En cualquier caso en mis explicaciones no doy el código resuelto, sino indicaciones de que hacer para enmendar tus errores...




Si tienes cualquier duda más no temas en hacerla y disculpa si te prejuzgo un poco, pero hay muchos vivos que quieren sus tareas hechas...
Y bueno

-Bueno, pués supuse que era algo así. Yo voy a la secundaria y tuve una profesora que a la hora de hacer un exámen le pedía alguno de los años anteriores a otros profesores y ni se fijaba si se había correjido algo...
Era ing en sistemas y no tenía más p*** idea de como programar... Ni siquiera las cosas más simples xD...
Profesores como esos hay por todas partes, lo peor que te puede pasar es que ensima sean unos tercos y no acepten una acotación del alumno... Pero en programación no hay mucha vuelta basta apretar F9 para darse cuenta quién tenía razón...



-Con respecto a la estructura cola, la parte positiva de tener declarado el tipo de dato nodcola es la posibilidad de retornar ese tipo (aunque no declares más de una variable de ese tipo)
Un ejemplo de ésto:

#include <stdio.h>
#include <stdlib.h>
 
struct punto {
       int x, y;
       };
 
struct punto funcion (void) {
     struct punto p;
     p.x=0;
     p.y=0;
     return p;
     }
 
int main(int argc, char *argv[])
{
  struct punto a;
  a.x=6;
  a.y=6;
  printf ("%i %i\n", a.x, a.y);
  a = funcion ();
  printf ("%i %i\n", a.x, a.y);
  system("PAUSE");	
  return 0;
}
 

Debo reconocer que lo que aquí planteas me ha hecho dudar de mis convicciones. Pero he probado y te paso un ejemplo para que compiles y te des cuenta por tigo mismo que pueden existir estructuras globales (siempres que la variable sea declarada fuera de toda función)...

#include <stdio.h>
#include <stdlib.h>
 
struct punto {
       int x, y;
       };
struct punto p;
 
void funcion (void) {
     p.x=0;
     p.y=0;
     return;
     }
 
int main(int argc, char *argv[])
{
  p.x=6;
  p.y=6;
  printf ("%i %i\n", p.x, p.y);
  funcion ();
  printf ("%i %i\n", p.x, p.y);
  system("PAUSE");	
  return 0;
}
 

Osea una cosa es la definición de la estructura

struct punto {
       int x, y;
       };

Y otra distinta la declaración de la variable del tipo de esa estructura:

struct punto p;

Si la definición de la estructura (de la plantilla como dices tu) está fuera de cualquier función (main es una), significa que en todo el código podrás declarar variables de ese tipo...
Si la declaración de la variable está fuera de toda función, esa variable será visible para todas las funciones...



-Con lo que te puse sobre las referencias, ahora me doy cuenta que sólo se puede hacer en c++, es para ahorrarse tantos (*) y evitar errores de distracción que pueden ser difiíciles de detectar. Un ejemplo

Es lo mismo hacer esto:

#include <stdio.h>
#include <stdlib.h>
 
void funcion (int *x) {
     *x=0;
     return;
     }
 
int main(int argc, char *argv[])
{
  int a;
  a=6;
  printf ("%i\n", a);
  funcion (&a);
  printf ("%i\n", a);
  system("PAUSE");	
  return 0;
}
 

Que esto:

#include <cstdlib>
#include <iostream>
 
using namespace std;
 
void funcion (int &x) {
     x=0;
     return;
     }
 
int main(int argc, char *argv[])
{
    int a;
    a=6;
    printf ("%i\n", a);
    funcion (a);
    printf ("%i\n", a);
    system("PAUSE");
    return 0;
}
 

Pero lo último, como ves, lo tuve que hacer en C++ porque en C no existe...



-En cuanto a la función malloc, este sí que es un problema importante, y puede traerte comportamientos no deseados del programa (por ejemplo cuando sale el cartelito que dice que el programa "no responde"), y luego tu puedes pensar que el problema deriva de no estar pasando por referencia las variables ya que así te funciona "de casualidad":

La memoria utilizada hay q reservarla (por eso declaras las variables, para que tu programar sepa cuánta memoria reservar) Pero...  ¿que sucede en casos como éste que necesito ir declarando nuevos nodos a medida que los voy necesitando?

Bueno en este caso se recuerre a funciones como éstas que reservan un pedacito de memoria de determinado tamaño. La función malloc cuando es llamada, reserva una memoria del tamaño que se le pase por argumento. Ahora... ¿como manejamos la memoria que ha reservado dicha función?. Pues porque la función devuelve la dirección de memoria del espacio que te reservo...
Así si yo quiero declarar un nuevo nodo tengo que tener en claro:
-cuanta memoria reservar, osea, cuanta memoria ocupa el nodo.
-un puntero hacia un tipo nodo, para poder guardar la dirección de la memoria reservada.
Para el primer apartado, tengo que saber el peso de un nodo. De que tipo es el nodo? (Struct Componente). Y por ende uso la función sizeof para saber cuanto pesa...
Para lo segundo apartado, declaro un puntero del tipo (struct componente*) para almacenar la dirección de memoria devuelta (lo habíamos definido como Puntero a este tipo)

Puntero a;
a = (Puntero) malloc (sizeof(struct Componente);
 

*el "(Puntero)" es porque malloc devuelve un puntero void (void*) y tienes que hacer la conversión...


-Bueno, espero que te quede claro que un código vale más que mil explicaciones... por ende cuando no entiendas algo, has tu propio "experimento" como los ejemplos que te puse