SoloCodigo

Bastante interesante. No conocía unlink. Pa' la otra me documento bien de las respuestas de los demás.

Sí, cada que quieras usar la variable a la que apunta tu apuntador, dentro de la función, necesitas indicarlo con el operador * (indirección).

   Recuerda que el * (asterisco) puede ser usado de estas dos formas: como el operador indireccion que te permite tratar a un apuntador como si de una variable se tratase, y para indicar que una variable será apuntador en una declaración.

Si tu función recibe un puntero como argumento, por ejemplo, en la definición:

void funcion(int *entero)
{
  ...
}

y en la llamada:

int *ip;      // Creación del puntero
int numero = 5;      // Variable que vale 5
ip = №      // ip apunta a numero

funcion(ip);      // Llamada a la función

dentro de la función tienes que usar el * cada que quieras usar la variable a la que apuntas. Checa este ejemplo:

int doble(int *entero)
{
  int numero;
  numero = (*entero) + (*entero);
  return (numero);
}

   El uso de apuntadores a estructuras como argumentos de funciones en C es tan común que cuando quieras acceder a un miembro de una estructura apuntada puedes hacerlo de manera abreviada con el operador -> (flecha). Por ejemplo, podrías tener algo como esto:

funcion x(struct TPunto *punto)
{
  int suma;
  ...
  punto->coordenadax = 5;
  punto->coordenaday = 2;
  suma = (punto->coordenadax) + (punto->coordenaday);
  ...
}

   Nota que arriba no se usó nunca el operador * para tratar el apuntador de la estructura como una variable, y el operador . (punto) para acceder a los miembros de la misma. Estas dos cosas las hace de manera automática el operador ->.

   Espero esto te sirva de algo.

"struct conjunto *A,*B,*C;
es decir, como punteros (y no he echo ningun typedf ni nada de eso)
cuando llame a la funcion yo le pasaria el C que es el que voy a modificar como doble puntero ¿no?"

   No, simplemente le pasas a la función el nombre del apuntador a estructura tal cual, C. No necesitas dobles punteros para eso.

   La definición de tu función quedaría:

   void interseccion(struct conjunto *A, struct conjunto *B, struct conjunto *C)
   {
     ...
   }

   y la llamada a la misma quedaría:

   struct conjunto *A, *B, *C;
   ...
   (Haces que tus apuntadores apunten a estructuras reales ya sea con malloc o de cualquier otra forma)
   ...
   interseccion(A, B, C);

   o en caso de estar utilizando estructuras en sí y no apuntadores a estructuras, pero quieres que tu función siga trabajando con apuntadores a estructuras:

   struct conjunto A, B, C;
   ...
   interseccion(&A, &B, &C);

   No importa si solo vas a escribir en una de las tres estructuras, es una buena práctica de programación utilizar apuntadores a estructuras como parámetros de funciones, aún si solo vas a leer de ellas, ya que de otro modo la estructura completa se copia en el argumento de la función, mientras que con el uso de apuntadores solo se copia su dirección de memoria. El operador & (ampersand) obtiene la dirección de memoria de una variable misma que se puede almacenar en una variable de tipo apuntador.

   Los dobles apuntadores o apuntadores a apuntadores pueden ser usados para muchas cosas. Uno de sus usos más comunes puede ser la creación de arreglos de cadenas dinámicos, ya que en sí un arreglo es en escencia un apuntador, y una cadena es un apuntador o un arreglo de caracteres, por lo tanto un arreglo dinámico de cadenas es un apuntador a apuntadores de caracteres.

   Los apuntadores a apuntadores no son más que un apuntador que es capaz de contener la dirección de memoria de otros apuntadores, los cuales a su vez pueden guardar direcciones de memoria de algún tipo de variable. Algo como:

   struct punto **x;

significa "una variable llamada x que apunta a una dirección de memoria donde se encuentra otra dirección de memoria donde hay una estructura del tipo punto".



   Cualquier otra duda exprésala.