Question

I know that when defining a an enum you can enumerate through the list numerically:

typedef enum MONTH { Jan = 1, Feb, March, ... };

Can you enumerate through values in a struct the same way? I basically want to loop through the values in a struct using a for or while loop.

struct items {char *item_name, int item_value};

struct items Items_list[] =
{ 
    "item 1", 2000,
    "item 2", 3600,
    ....
};

Language used is C.

Edit: I may have just answered my own question since what I had in mind is an array of structs. Will leave the question up for now however.

Answer 1

This declaration and initializer combination are invalid. (The question changed while the original version of this answer was written.)

If you are asking “is there a way to access the first member of the structure, then the second, without knowing the structure element names”, then the answer is ‘no, not without careful encoding beforehand’.

---

The careful coding involves multiple steps. For each element, you need an encoding of the type, the offset of the member in the structure, and perhaps the size of the member (if the encoding of the type does not give that to you anyway):

typedef enum { MT_INT, MT_CHAR_PTR, ... } MemberType;

typedef struct MemberAccess
{
    const char *name;
    size_t      offset;
    MemberType  type;
} MemberAccess;

static const MemberAccess members[] =
{
    "item_name",  offsetof(struct items, item_name),  MT_CHAR_PTR },
    "item_value", offsetof(struct items, item_value), MT_INT      },
};

And now, with excruciating care, you can write code to either get or set the value in the Nth member of a struct item pointed at by a particular pointer. However, doing so is still far from trivial.

int get_int(const void *data, const MemberAccess *member)
{
    assert(member->type == MT_INT);
    return (*(const int *)((const char *)data + member->offset));
}

GCC notwithstanding, you need the cast to a character pointer; you cannot legitimately do pointer arithmetic on void *.

You might then invoke:

int value = get_int(&Items_list[1], &members[1]);

to get at the integer value of the second field of the second element of the array.

This is so excruciating to deal with that there have to be excellent reasons to go through the overhead. There can be such reasons. I know of a system with 400 configuration parameters (which is a problem in its own right, but lets pretend that’s OK; they’ve accumulated over 20 years of development) stored in a structure with heterogeneous types for the members. The code that manipulates it is written out 400 times – ouch! – because it doesn’t use a system driven off an analogue of the MemberAccess structure. The code would be a lot more compact than it currently is because there are about a dozen data types to deal with, so most of the code is repetitive. Another way of reducing the complexity of that code would be to make everything into a string, but there are issues with that transformation too.