que - elemento de acceso de struct pasado a un puntero void*

punteros y arreglos en c

Question

Estoy trabajando con una estructura de datos de árbol de búsqueda binaria para ordenar una serie de estructuras con las definiciones de tipo:

typedef struct {
char c;
int index;
} data_t;
typedef struct node node_t;
typedef node {
void *data;
node_t *left;
node_t *right;
}

El node_t typedef proviene de una biblioteca que se me proporcionó para este fin, presumiblemente con un puntero void * para asegurar el polimorfismo. node pasará a la función:

static void *recursive_search_tree(node_t *root, void *key, int cmp(void*,void*))

Dentro de la función recursive_search_tree, deseo poder modificar el código para usar el elemento de índice como condición para encontrar la coincidencia más cercana al índice del pase lineal sobre una matriz de caracteres, lo que en última instancia implicaría pasar un data_t a *key y key->index se accede dentro de la función.

La pregunta

¿Es posible acceder a key->index donde key es un void* apunta a una estructura de data_t , o esto solo sería posible si se declarara data_t como el tipo de clave? He intentado hacer esto último, sin embargo, incluso lanzar el puntero a un int no parece pasar el compilador.

Answer 1

Claro que es posible, *data_t key como tipo *data_t . (¡Siempre que eso sea realmente lo que señala la key !)

key /* argument of type void* */
(data_t*)key /* cast as type data_t* */
((data_t*)key)->index /* dereferenced */

Aquí hay un ejemplo simple:

#include <stdlib.h>
#include <stdio.h>
typedef struct {
char c;
int index;
} data_t;
typedef struct node {
void *data;
struct node *left;
struct node *right;
} node_t;
static int cmp(void *lhs, void *rhs)
{
return ((data_t *)lhs)->index - ((data_t *)rhs)->index;
}
int main(void)
{
data_t d0;
data_t d1;
d0.c = ''A'';
d0.index = 1;
d1.c = ''B'';
d1.index = 2;
printf("d0 < d1? %s/n", (cmp((void *)&d0, (void *)&d1) < 0 ? "yes" : "no"));
printf("d1 < d0? %s/n", (cmp((void *)&d1, (void *)&d0) < 0 ? "yes" : "no"));
return EXIT_SUCCESS;
}

Answer 2

Esto es tipo inseguro, como cualquier uso de vacío. El uso del vacío generalmente se debe a que el intermediario se aferra a algo que no utiliza para la conveniencia de otra persona. Esta es una función C que te permite mantener lo que quieras en un árbol. Todo lo que hace es devolver el puntero que le des.

En tu función de búsqueda

int cmp(void* dt1, void* dt2)
{
data_t* data1 = (data_t*)dt1;
data_t* data2 = (data_t*)dt2;
/* Do what you need with data1 and data2 here */
}

Debería dejarte hacer lo que necesites. El problema que tienes es que debes convertir tus valores dentro de la función. Los parámetros de cmp deben coincidir exactamente con la API de la biblioteca que está utilizando, que dice nulo * para los parámetros.