How to access members of a `struct' according to a variable integer in C?

Question

Suppose I have this struct (which incidentally contain bit-fields, but you shouldn't care):

struct Element {
    unsigned int a1 : 1;
    unsigned int a2 : 1;
    ...
    unsigned int an : 1;
};

and I want to access the i'th member in a convenient way. Let's examine a retrieval solution.
I came up with this function:

int getval(struct Element *ep, int n)
{
    int val;
    switch(n) { 
         case 1: val = ep->a1; break;
         case 2: val = ep->a2; break;
         ...
         case n: val = ep->an; break;
    }
    return val;
}

But I suspect that there is a much simpler solution. Something like array accessing style, maybe.

I tried to do something like that:

 #define getval(s,n)   s.a##n

But expectedly it doesn't work.
Is there a nicer solution?

Answer 1

Unless you have specific knowledge of the underlying structure of the struct, there is no way to implement such a method in C. There are all sorts of problems that will get in the way including

• Members of different sizes
• Packing issues
• Alignment issues
• Tricks like bitfields will be problematic

You're best off implementing a method by hand for your struct which has a deep understanding of the internal members of the structure.

Answer 2

No, there is no simple way to do this easier. Especially for bitfields, that are hard to access indirectly through pointers (you cannot take the address of a bitfield).

You can of course simplify that function to something like this:

int getval(const struct Element *ep, int n)
{
    switch(n)
    {
      case 1: return ep->a1;
      case 2: return ep->a2;
      /* And so on ... */
    }
    return -1; /* Indicates illegal field index. */
}

And it seems obvious how the implementation can be further simplified by using a preprocessor macro that expands to the case-line, but that's just sugar.

Answer 3

If every field in your struct is an int, then you should basically be able to say

int getval(struct Element *ep, int n)
{
    return *(((int*)ep) + n);
}

This casts the pointer to your struct to a pointer to an array if integers, then accesses the nth element of that array. Since everything in your struct seems to be an integer, this is perfectly valid. Note that this will fail horribly if you ever have a non-int member.

A more general solution would be to maintain an array of field offsets:

int offsets[3];
void initOffsets()
{
    struct Element e;
    offsets[0] = (int)&e.x - (int)&e;
    offsets[1] = (int)&e.y - (int)&e;
    offsets[2] = (int)&e.z - (int)&e;
}

int getval(struct Element *ep, int n)
{
    return *((int*)((int)ep+offsets[n]));
}

This will work in the sense that you'll be able to call getval for any of the int fields of your struct, even if you have other non-int fields in your struct, since the offsets will all be correct. However, if you tried to call getval on one of the non-int fields it would return a completely wrong value.

Of course, you could write a different function for each data type, e.g.

double getDoubleVal(struct Element *ep, int n)
{
    return *((double*)((int)ep+offsets[n]));
}

and then just call the proper function for whichever datatype you'd want. Incidentally, if you were using C++ you could say something like

template<typename T>
T getval(struct Element *ep, int n)
{
    return *((T*)((int)ep+offsets[n]));
}

and then it would work for whatever datatype you'd want.

Answer 4

If the structure really is as simple as described, you might use a union with an array (or a cast to an array) and some bit-access magic (as in How do you set, clear and toggle a single bit in C?).

As Jared says, the general case is hard.

Answer 5

Why not build getval() in to the struct?

struct Whang {
int a1;
int a2;
int getIth(int i) {
 int rval;
 switch (i) {
  case 1: rval = a1; break;
  case 2: rval = a2; break;
  default : rval = -1; break;
 }
 return rval;
}

};

int _tmain(int argc, TCHAR argv[])
{
Whang w;
w.a1 = 1;
w.a2 = 200;

int r = w.getIth(1);

r = w.getIth(2);

return 0;

}

getIth() would have knowledge of the internals of Whang, and could deal with whatever it contained.

Answer 6

If your struct was anything except bitfields, you could just use array access, if I'm right in remembering that C guarantees that a series of members of a struct all of the same type, has the same layout as an array. If you know which bits in what order your compiler stores bitfields into integer types, then you could use shift/mask ops, but that's then implementation-dependent.

If you want to access bits by variable index, then it's probably best to replace your bitfields with an integer containing flag bits. Access by variable really isn't what bitfields are for: a1 ... an are basically independent members, not an array of bits.

You could do something like this:

struct Element {
    unsigned int a1 : 1;
    unsigned int a2 : 1;
    ...
    unsigned int an : 1;
};

typedef unsigned int (*get_fn)(const struct Element*);

#define DEFINE_GETTER(ARG) \
    unsigned int getter_##ARG (const struct Element *ep) { \
        return ep-> a##ARG ; \
    }

DEFINE_GETTER(1);
DEFINE_GETTER(2);
...
DEFINE_GETTER(N);

get_fn jump_table[n] = { getter_1, getter_2, ... getter_n};

int getval(struct Element *ep, int n) {
    return jump_table[n-1](ep);
}

And some of the repetition could be avoided by the trick where you include the same header multiple times, each time having defined a macro differently. The header expands that macro once for each 1 ... N.

But I'm not convinced it's worth it.

It does deal with JaredPar's point that you're in trouble if your struct mixes different types - here all the members accessed via a particular jump table must of course be of the same type, but they can have any old rubbish in between them. That still leaves the rest of JaredPar's points, though, and this is a lot of code bloat for really no benefit compared with the switch.

Answer 7

I think your real solution is to not use bitfields in your struct, but instead define either a set type or a bit array.

Answer 8

I suggest code generation. If your structures don't contain huge amount of fields you can auto generate routines for each field or for a range of fields and use them like:

val = getfield_aN( myobject, n );

or

val = getfield_foo( myobject );

Answer 9

What about converting from bitfields to a bitmask?

Answer 10

If you want to access your structure using both element index:

int getval(struct Element *ep, int n)

and by name:

ep->a1

then you are stuck with some hard to maintain switch like method that everyone has suggested.

If, however, all you want to do is access by index and never by name, then you can be a bit more creative.

First off, define a field type:

typedef struct _FieldType
{
    int size_in_bits;
} FieldType;

and then create a structure definition:

FieldType structure_def [] = { {1}, {1}, {1}, {4}, {1}, {0} };

The above defines a structure with five elements of size 1, 1, 1, 4 and 1 bits. The final {0} marks the end of the definition.

Now create an element type:

typedef struct _Element
{
    FieldType *fields;
} Element;

To create an instance of an Element:

Element *CreateElement (FieldType *field_defs)
{
  /* calculate number of bits defined by field_defs */
  int size = ?;
  /* allocate memory */
  Element *element = malloc (sizeof (Element) + (size + 7) / 8); /* replace 7 and 8 with bits per char */
  element->fields = field_defs;
  return element;
}

And then to access an element:

int GetValue (Element *element, int field)
{
   /* get number of bits in fields 0..(field - 1) */
   int bit_offset = ?;
   /* get char offset */
   int byte_offset = sizeof (Element) + bit_offset / 8;
   /* get pointer to byte containing start of data */
   char *ptr = ((char *) element) + byte_offset;
   /* extract bits of interest */
   int value = ?;
   return value;
}

Setting values is similar to getting values, only the final part needs changing.

You can enhance the above by extending the FieldType structure to include information about the type of value stored: char, int, float, etc, and then write accessors for each type which checks the required type against the defined type.

Skizz

Answer 11

If you have

1. Only bitfields, or all the bitfields first in your struct
2. less than 32 (or 64) bitfields

then this solution is for you.

#include <stdio.h>
#include <stdint.h>

struct Element {
  unsigned int a1 : 1;
  unsigned int a2 : 1;
  unsigned int a3 : 1;
  unsigned int a4 : 1;
};

#define ELEMENT_COUNT 4 /* the number of bit fields in the struct */

/* returns the bit at position N, or -1 on error (n out of bounds) */
int getval(struct Element* ep, int n) 
{
  if(n > ELEMENT_COUNT || n < 1)
    return -1;

  /* this union makes it possible to access bit fields at the beginning of 
     the struct Element as if they were a number.
   */
  union {
    struct Element el;
    uint32_t bits;
  } comb;

  comb.el = *ep;
  /* check if nth bit is set */
  if(comb.bits & (1<<(n-1))) {
    return 1;
  } else {
    return 0;
  }
}

int main(int argc, char** argv)
{
  int i;
  struct Element el;

  el.a1 = 0;
  el.a2 = 1;
  el.a3 = 1;
  el.a4 = 0;

  for(i = 1; i <= ELEMENT_COUNT; ++i) {
    printf("el.a%d = %d\n", i, getval(&el, i));
  }  

  printf("el.a%d = %d\n", 8, getval(&el, 8));

  return 0;
}