Se que es mal dia para preguntar sobre programacion, pero...

[Locke]

Esperemos que alguien me pueda ayudar, que tengo mucha prisa xD

En fin, esta es una estructura que he creado:


typedef struct
{
intcoord_t pos;
dir_t dir;
struct node_t *prev;
struct node_t *next;
}node_t;

Y esta es la funcion que la usa:


void createNode (node_t *node, dir_t dir)
{
node->next = (node_t *)calloc(1, sizeof(node_t));
node->next->pos = next(node->pos);
node->next->dir = dir;
node->next->prev = node;
node->next->next = NULL;
}

El error que me da es "dereferencing pointer to incomplete type" en la segunda, tercera, cuarta y quinta lineas de la funcion. Alguien tiene alguna pista de por que me pasa esto? Agradeceria rapidez, que voy un poco pillao de tiempo... :)

Thx

[Wave]

No estoy seguro pero prueba asi.


void createNode (node_t *node, dir_t dir)
{
node->next = (node_t *)calloc(1, sizeof(node_t));
(node->next)->pos = next(node->pos);
(node->next)->dir = dir;
(node->next(->prev = node;
(node->next)->next = NULL;
}

[Locke]

nada :(

Pero txh

[ilarri]

locke, ningun dia es mal dia para preguntar...aunk yo no te puedo ayudar, pero seguro k alguien si k podra.
ademas, no existen ni malas horas y preguntas tontas, solo malas respuestas.

feliz año nuevo!!!

[Wave]

typedef struct node_t
{
intcoord_t pos;
dir_t dir;
node_t *prev;
node_t *next;
};




void createNode (node_t *node, dir_t dir)
{
node->next = (node_t *)calloc(1, sizeof(node_t));
( node->next)->pos = next(node->pos);
(node->next)->dir = dir;
(node->next)->prev = node;
(node->next)->next = NULL;
}

[Locke]

Nada, asi me da un parse error en la declaracion del tipo node_t, porque llama a un tipo que aun no ha sido definido por completo...

Lo raro es que no es la primera vez que uso una estructura similar en el codigo:

Es otra cadena doblemente enlazada, con un cursor que apunta al primer y al ultimo elemento.


typedef struct
{
coord_t start;
coord_t end;
struct line_t *prev;
struct line_t *next;
}line_t;

typedef struct
{
line_t *first;
line_t *last;
}path_t;

Y para añadir:


void addLine (path_t *path, coord_t start)
{
line_t *temp = path->first;

path->first = (line_t *) calloc (1, sizeof(line_t));
path->first->start = path->first->end = start;
path->first->dir = dir;
path->first->next = NULL;
path->first->prev = temp;

if (temp != NULL)
temp->next = path->first;
}

Eso unicamente me da unos warnings (y mira que me joden, porque no me gusta que me aparezcan) en la ultima y antepenultima linea, al asignar un tipo (line_t *) a un (struct line_t *), pero funciona correctamente.

La diferencia es basicamente que uso un cursor, y no los propios punteros de los nodos, pero es que la de arriba se llama recursivamente, y no se me ha ocurrido como implementarla de otra manera...

A ver si con esta pista ya sale algo.

[Wave]

Pues a mi me compilaba en visualc++

[Locke]

Seguro :(

El gcc no se lo traga...

[Aiken]

typedef struct node_t
{
intcoord_t pos;
dir_t dir;
void *prev;
void *next;
};

prueba asi, y lo unico luego en el calloc

node->next = (node_t *)calloc(1, sizeof(node_t));

puede que tengas que usar el cast (node_t *) en mas sitios ya que lo has declarado como void * de esta forma ;)

Aiken

[Locke]

Muchas gracias, asi por lo menos ya me compila. Ahora queda ver si hace bien su funcion.

Las referencias a los componentes de la estructura ahora las tengo que hacer asi (supongo que es la manera correcta):

((node_t *)(node->next))->dir = dir;ç

Ya comentare si me ha funcionado todo bien :)

[Patxi]

El problema es que en la definición estabas usando un tipo que aún no había sido definido:


typedef struct
{
intcoord_t pos;
dir_t dir;
struct node_t *prev; //node_t aún no está definido
struct node_t *next; //lo mismo que antes
}node_t;

Gcc no se lo traga porque es un compilador que hace solo una pasada, pero el compilador del Visual C++ es de varias pasadas, y cuando se encuentra con node_t lo guarda como un simbolo no resuelto. Al hacer la 2ª pasada ya sabe lo que es node_t.

Lo que dice Aiken está bien. También puedes probar esto:


struct node_t_ {
intcoord_t pos;
dir_t dir;
struct node_t_ *prev;
struct node_t_ *next;
};

typedef struct node_t_ node_t;

La verdad es que esto último lo he puesto de cabeza. Igual no va y me he colado.

saludos y feliz año nuevo

[oankali]

Sé que llego tarde porque supongo que era para el ADIC, pero acabo de leer el mensage y aquí te doy mi solución, la que uso en todas mis estructuras.
De echo es la misma solución que patxi pero cambiando mucho menos tu código:




typedef struct node_t_
{
intcoord_t pos;
dir_t dir;
struct node_t_ *prev;
struct node_t_ *next;
} node_t;


Y por si te puede servir de algo, en mi web (http://www.nekanium.com/gp32) encontrarás la librería list.h que te permite gestionar listas dinámicas de objetos. Yo la utilizo en todos mis proyectos.

[Locke]

Gracias a todos. Si que era para la ADIC, pero me vendran bien las ideas para futuros proyectos.

Oankali, esa solucion es justo la que estaba buscando, sabia que era algo asi pero no conseguia dar con ello. Y gracias por la lib, vere que tal me va con ella :)