用指针访问结构成员

Question

In C, I am having a structure like this

typedef struct
{
 char *msg1;
 char *msg2;
 .
 .
 char *msgN;
}some_struct;

some_struct struct1;
some_struct *pstruct1 = &struct1;

I want to keep a pointer or a varible which when incremented or decremented, gives the next/last member variable of this structure. I do not want to use array of char * since it is already designed like this.

I tried using the union and structure combination, but I don't know how to write code for that.

Thought iterator may help but this is C. Any suggestions ?

Answer 1

You can't do that, safely. You can take a chance that the adjacent character pointers are really adjacent (with no padding) as if they were in an array, but you can't be sure so that's pretty much straight into the undefined behavior minefield.

You can abstract it to an index, and do something like:

char * get_pointer(some_struct *p, int index)
{
  if(index == 0)
    return p->msg1;
  if(index == 1)
    return p->msg2;
  /* and so on */
  return NULL;
}

Then you get to work with an index which you can increment/decrement freely, and just call get_pointer() to map it to a message pointer when needed.

Answer 2

You can do this using strict C, but you need to take certain precautions to ensure compliance with the standard. I will explain these below, but the precautions you need to take are:

(0) Ensure there is no padding by including this declaration:

extern int CompileTimeAssert[
    sizeof(some_struct) == NumberOfMembers * sizeof(char *) ? 1 : -1];

(1) Initialize the pointer from the address of the structure, not the address of a member:

char **p = (char **) (char *) &struct1;

(I suspect the above is not necessary, but I would have to insert more reasoning from the C standard.)

(2) Increment the pointer in the following way, instead of using ++ or adding one:

p = (char **) ((char *) p + sizeof(char *));

Here are explanations.

The declaration in (0) acts as a compile-time assertion. If there is no padding in the struct, then the size of the struct equals the number of members multiplied by the size of a member. Then the ternary operator evaluates to 1, the declaration is valid, and the compiler proceeds. If there is padding, the sizes are not equal, the ternary operator evaluates to -1, and the declaration is invalid because an array cannot have a negative size. Then the compiler reports an error and terminates.

Thus, a program containing this declaration will compile only if the struct does not have padding. Additionally, the declaration will not consume any space (it only declares an array that is never defined), and it may be repeated with other expressions (that evaluate to an array size of 1 if their condition is true), so different assertions may be tested with the same array name.

Items (1) and (2) deal with the problem that pointer arithmetic is normally guaranteed to work only within arrays (including a notional sentinel element at the end) (per C 2011 6.5.6 8). However, the C standard makes special guarantees for character types, in C 2011 6.3.2.3 7. A pointer to the struct may be converted to a pointer to a character type, and it will yield a pointer to the lowest addressed byte of the struct. Successive increments of the result, up to the size of the object, yield pointers to the remaining bytes of the object.

In (1), we know from C 2011 6.3.2.3 7, that (char *) &struct1 is a pointer to the first byte of struct1 . When converted to (char **) , it must be a pointer to the first member of struct1 (in particular thanks to C 2011 6.5.9 6, which guarantees that equal pointers point to the same object, even if they have different types).

Finally, (2) works around the fact that array arithmetic is not directly guaranteed to work on our pointer. That is, p++ would be incrementing a pointer that is not strictly in an array, so the arithmetic is not guaranteed by 6.5.6 8. So we convert it to a char * , for which increments are guaranteed to work by 6.3.2.3 7, we increment it four times, and we convert it back to char ** . This must yield a pointer to the next member, since there is no padding.

One might claim that adding the size of char ** (say 4) is not the same as four increments of one char , but certainly the intent of the standard is to allow one to address the bytes of an object in a reasonable way. However, if you want to avoid even this criticism, you can change + sizeof(char *) to be +1+1+1+1 (on implementations where the size is 4) or +1+1+1+1+1+1+1+1 (where it is 8).

Answer 3

Take the address of the first member and store it to char ** :

char **first = &struct1.msg1;
char **last = &struct1.msg1 + sizeof(some_struct) / sizeof(char *) - 1;

char **ptr = first;  /* *ptr is struct.msg1 */
++ptr;               /* now *ptr is struct1.msg2 */

This assumes that the structure only contains char * members.