C méthode d'itération à travers les membres d'une structure comme un tableau?

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

de cette façon, vous pouvez accéder à chaque champ x, y ou z indépendamment ou itérer sur eux en utilisant le tableau Vect3_A. Cette solution n'a rien coûté en mémoire ou en calcul mais nous pouvons être un peu loin d'une solution C ++.

Le problème en C avec ce que vous essayez de faire est que vous devez savoir comment passer à travers une structure (c'est-à-dire que vous devez connaître les types). La raison std :: vecteur code> fonctionne comme c'est parce qu'il utilise des modèles (un C ++ code> concept). Cela dit, cela dit, vous pourriez essayer quelque chose de légèrement différent de ce que vous avez suggéré. Si vous ne souhaitez pas utiliser de tableaux, vous pouvez stocker des types génériques. Cependant, lors de la récupération des données et de l'utiliser, l'utilisateur devra savoir quel type de données il s'attend à s'attendre. Ci-dessous évite les matrices (bien qu'une solution potentiellement plus propre existe dans les utiliser) et a une liste liée à la liste de quelque chose qui vous donne la presque même flexibilité de std :: vecteur code> Ceci est une liste liée avec les opérations O (n) code> pour tout (vous pouvez être intelligente et inverser la liste à réaliser, peut-être, o (1) code> insert, mais ceci est simplement par 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;
}