按地址访问struct成员

Question

Consider a struct with two members of integer type. I want to get both members by address. I can successfully get the first, but I'm getting wrong value with the second. I believe that is garbage value. Here's my code:

#include <stdio.h>

typedef struct { int a; int b; } foo_t;

int main(int argc, char **argv)
{

  foo_t f;
  f.a = 2;
  f.b = 4;
  int a = ((int)(*(int*) &f));
  int b = ((int)(*(((int*)(&f + sizeof(int)))))); 
  printf("%d ..%d\n", a, b);
  return 0;
}

I'm getting:

2 ..1

Can someone explain where I've gone wrong?

Answer 1

The offset of the first member must always be zero by the C standard; that's why your first cast works. The offset of the second member, however, may not necessarily be equal to the size of the first member of the structure because of padding.

Moreover, adding a number to a pointer does not add the number of bytes to the address: instead, the size of the thing being pointed to is added. So when you add sizeof(int) to &f , sizeof(int)*sizeof(foo_t) gets added.

You can use offsetof operator if you want to do the math yourself, like this

int b = *((int*)(((char*)&f)+offsetof(foo_t, b)));

The reason this works is that sizeof(char) is always one, as required by the C standard.

Of course you can use &f.b to avoid doing the math manually.

Answer 2

Your problem is &f + sizeof(int) . If A is a pointer, and B is an integer, then A + B does not, in C, mean A plus B bytes. Rather, it means A plus B elements, where the size of an element is defined by the pointer type of A . Therefore, if sizeof(int) is 4 on your architecture, then &f + sizeof(int) means "four foo_t s into &f , or 4 * 8 = 32 bytes into &f ".

Try ((char *)&f) + sizeof(int) instead.

Or, of course, &f.a and &f.b instead, quite simply. The latter will not only give you handy int pointers anyway and relieve you of all those casts, but also be well-defined and understandable. :)

Answer 3

The expression &f + sizeof(int) adds a number to a pointer of type foo_t* . Pointer arithmetic always assumes the pointer is to an element of an array, and the number is treated as a count of elements.

So if sizeof(int) is 4, &f + sizeof(int) points four foo_t structs past f , or 4*sizeof(foo_t) bytes after &f .

If you must use byte counts, something like this might work:

int b = *(int*)((char*)(&f) + sizeof(int));

... assuming there's no padding between members a and b .

But is there any reason you don't just get the value fb or the pointer &f.b ?

Answer 4

You can do &f.b , and skip the actual pointer math.

Here is how I would change your int b line:

int b = (int)(*(((int*)(&(f.b)))));

BTW, when I run your program as is, I get 2 ..0 as the output.

Answer 5

This works:

  int b = ((int)(*(int*)((int)&f + sizeof(int))));

You are interpreting &f as a pointer and when you are adding 4 (size of int) to it, it interprets it as adding 4 pointers which is 16 or 32 bytes depending on 32 vs 64 arch. If you cast pointer to int it will properly add 4 bytes to it.

This is an explanation of what is going on. I'm not sure what you are doing, but you most certainly should not be doing it like that. This can get you in trouble with alignment etc. The safe way to figure out offset of a struct element is:

  printf("%d\n", &(((foo_t *)NULL)->b));