C méthode d'itération sur une struct membres comme un tableau?

Si tous vos champs de structure sont du même type, vous pouvez utiliser un syndicat comme suit:

typedef union vec3_u
{
    struct vec3_s {
        float x, y, z;
    };
    float vect3_a[3];
}
vec3;

De cette façon, vous pouvez accéder à chaque x, y ou z champ de façon indépendante ou itérer sur eux à l'aide de la vect3_a tableau. Cette solution ne coûte rien en terme de mémoire ou de calcul, mais on peut être un peu loin du C++ comme solution.

Le problème en C avec ce que vous essayez de faire est que vous avez besoin de savoir comment se déplacer dans une structure (c'est à dire vous avez besoin de connaître le type). La raison std::vector<T> fonctionne comme il le fait c'est parce que c'est à l'aide de modèles (un C++ concept). Maintenant, cela dit, vous pouvez essayer quelque chose de légèrement différent de ce que vous avez suggéré. Si vous ne souhaitez pas utiliser les tableaux, vous pouvez stocker des types génériques. Cependant, lors de la récupération des données et de l'utilisation, l'utilisateur devra savoir quel type de données qu'il ou elle attend. Ci-dessous évite les tableaux (bien que, potentiellement plus propre solution existe dans leur utilisation) et a une liste liée de mise en œuvre de quelque chose qui vous donne presque la même souplesse de std::vector<T> (avantages de performance de côté puisque c'est une liste liée avec O(n) opérations pour tout (vous pouvez être intelligent et d'inverser la liste pour atteindre, peut-être, O(1) insérer, mais c'est simplement pour l'exemple)

#include <stdio.h>
#include <stdlib.h>
typedef struct _item3_t
{
void *x, *y, *z;
struct _item3_t* next;
} item3_t;
typedef struct
{
item3_t* head;
} vec3_t;
void insert_vec3(vec3_t* vec, void* x, void* y, void* z)
{
item3_t* item = NULL;
item3_t* tmp  = NULL;
int i = 0;
if(vec == NULL)
return;
item = malloc(sizeof(item3_t));
item->x = x;
item->y = y;
item->z = z;
item->next = NULL;
tmp = vec->head;
if(tmp == NULL) { //First element
vec->head = item;
} else {
while(tmp->next != NULL)
tmp = item->next;
tmp->next = item;
}
}
//This is one method which simply relies on the generic method above
void insert_vec3_float(vec3_t* vec, float x, float y, float z)
{
float* xv, *yv, *zv;
if(vec == NULL)
return;
xv = malloc(sizeof(float));
yv = malloc(sizeof(float));
zv = malloc(sizeof(float));
*xv = x;
*yv = y;
*zv = z;
insert_vec3(vec, xv, yv, zv);
}
void init_vec3(vec3_t* vec)
{
if(vec == NULL)
return;
vec->head = NULL;
}
void destroy_vec3(vec3_t* vec)
{
item3_t* item = NULL, *next = NULL;
if(vec == NULL)
return;
item = vec->head;
while(item != NULL) {
next = item->next;
free(item->x);
free(item->y);
free(item->z);
free(item);
item = next;
}
}
item3_t* vec3_get(vec3_t* vec, int idx)
{
int i = 0;
item3_t* item = NULL;
if(vec == NULL)
return NULL;
item = vec->head;
for(i = 0 ; i < idx && item != NULL ; ++i)
item = item->next;
return item;
}
void do_something(item3_t* item)
{
if(item == NULL)
return;
float x = *((float*)item->x);
float y = *((float*)item->y);
float z = *((float*)item->z);
//To do - something? Note, to manipulate the actual
//values in the vector, you need to modify their values
//at their mem addresses
}
int main()
{
vec3_t vector;
init_vec3(&vector);
insert_vec3_float(&vector, 1.2, 2.3, 3.4);
printf("%f %f %f\n", *((float*)vec3_get(&vector, 0)->x), *((float*)vec3_get(&vector, 0)->y), *((float*)vec3_get(&vector, 0)->z));
do_something(vec3_get(&vector, 0));
destroy_vec3(&vector);
return 0;
}

Ce code doit compiler droit hors de la boîte. Ce que vous avez ici est une liste chaînée qui est de votre "vecteur" (en particulier, un vec3 structure). Chaque nœud dans la liste (c'est à dire de chaque élément dans le std::vector<T> sens) a 3 éléments qui sont tous void pointeurs. Ainsi, vous pouvez stocker tout type de données que vous souhaitez ici. Le seul hic, c'est que vous avez besoin d'allouer de la mémoire pour ces pointeurs à point et lors de la suppression d'un élément, vous devez libérer de la mémoire (reportez-vous à la vec3_destroy méthode pour un exemple). Espérons que cela aide un peu plus pour comprendre comment ces pointeurs void peut fonctionner dans votre cas.

Pour récupérer les données, vous ne serez pas en mesure d'utiliser le [] la notation, mais vous pouvez utiliser le vec3_get méthode de la même manière. Le do_something méthode est un exemple de stub de quelque façon que vous pouvez être en mesure d'accomplir quelque chose de semblable à ce que vous avez mentionné dans l'OP.