Итерация по членам структуры того же типа в C

Самый простой способ — создать объединение, одна часть которого содержит каждого члена по отдельности, а другая — массив. Я не уверен, что дополнение, зависящее от платформы, может помешать выравниванию.

Большинство попыток использования объединения с массивом обречены на неудачу. У них есть неплохие шансы работать, пока вы используете только int, но для других, особенно меньших типов, они, вероятно, будут давать сбои довольно часто, потому что компилятор может (и особенно с меньшими типами часто будет) добавлять отступы между членами a struct, но не может делать это с элементами массива).

Однако в C есть макрос offsetof(), который вы можете использовать. Это дает смещение элемента в struct, поэтому вы можете создать массив смещений, а затем (с некоторой осторожностью в приведении) вы можете добавить это смещение к адресу структуры, чтобы получить адрес члена. Внимание при приведении заключается в том, что смещение находится в байтах, поэтому вам нужно привести адрес struct к char *, затем добавить смещение, а затем привести результат к типу члена (int в вашем случае).

С точки зрения языка: нельзя. элементы данных структуры не являются... э-э... "итерируемыми" в C, независимо от того, относятся ли они к одному типу или к разным типам.

Используйте массив вместо группы независимых членов.

Вы также можете использовать безымянный союз/структуру:

struct foo {
    union {
        struct {
            int mem1;
            int mem2;
            int mem3;
            int mem4;
        };
        int elements[4];
    };
};

foo thefoo;
for (int i = 0; i < 4; ++i) {
    thefoo.elements[i] = i;
}

Это может не работать на некоторых компиляторах, в этом случае вам придется явно указать объединение и структуру внутри foo,

Вот еще один подход; У меня никогда не было причин делать это, но это имеет то преимущество, что не искажает определение структуры. Создайте массив указателей на интересующие вас члены, а затем выполните итерацию по этому массиву:

typedef struct { int mem1; int mem2; int mem3, int mem4; } foo;
...
foo theStruct;
int *structMembers[4] = { &theStruct.mem1, &theStruct.mem2, 
                          &theStruct.mem3, &theStruct.mem4};
...
for (i = 0; i < 4; i++)
{
  printf("%d\n", *structMembers[i]);
}

Таким образом, вам не нужно беспокоиться о проблемах с выравниванием, и вы можете произвольно упорядочить, как вы хотите перебирать элементы (например, вы можете заказать так, чтобы прогулка была «mem4, mem3, mem2, mem1»).

    int* tmp = &data->mem1 ;  // explicitly get the address of the first int member

Как вы говорите, вы должны быть осторожны с выравниванием и другими проблемами с расположением памяти. Вы должны быть в порядке, делая это с ints.

Но я бы спросил, насколько читабельным это сделает ваш код.

Кстати,

    tmp += ( i * sizeof(foo) ) ;

Я не думаю, что это делает то, что вы думаете, но я не совсем уверен, что вы хотите. Используйте ++tmp;, если вы хотите перейти к следующему int элементу того же foo объекта.

Вы должны иметь возможность привести указатель foo к указателю int.

Более чистым решением было бы объявить foo следующим образом.

typedef struct
{
    int fooints[ 4 ] ;
} foo ;

Затем выполните итерацию по массиву int.

for ( int i = 0 ; i < 4 ; i++ )
{
    printf( "%d\n" , *( foo->fooints + i ) ) ;
}

Вы можете создать функции-члены для доступа и/или управления массивом int.

Лучший способ, который я нашел для итерации структур, которые имеют элементы одного и того же типа данных;

Создайте перечисление с нужными именами. Добавьте последний элемент для ограничения итерации. Создайте структуру, содержащую массив размером TOTAL_STRUCT_MEMBERS. Затем повторите с for.

enum StructMembers{
   data1,
   data2,
   data3,
   TOTAL_STRUCT_MEMBERS
};

struct DataStruct{
   int datas[TOTAL_STRUCT_MEMBERS];
};

// iterating
for(int i = 0; i < TOTAL_STRUCT_MEMBERS; i++)
{
   DataStruct.datas[i] = 0;
}

// Direct access
DataStruct.datas[data2] = 25;