按地址访问Struct中的元素

Question

I've done some research and I cant quite find what I'm looking for on here or google. Is there a way to access the elements in a Customer by address (and not by using customer[i].bottles). I cannot modify the struct so I cannot put the properties into an array.

typedef struct Customer {
  int id;
  int bottles;
  int diapers;
  int rattles;
} Customer;

Customer customers[100];

void setValue(int custInd, int propertyInd) {
  //propertyInd would be 1 for id, 2 for bottles
  //Attempting to set customers[0].bottles
  *(&customers[custInd]+propertyInd) = 5;
}

I thought I'd be able to do this but I got various errors. Knowing that the "bottles" value will be the second space in memory from the address of a Customer shouldn't i be able to directly set the spot.

I know this may be improper code but I would like to understand how and why does/doesnt work. I also promise I have reasons for attempting to do this over the conventional way hah

Answer 1

Instead of using propertyInd , perhaps pass an offset into the structure. That way, the code will work even if the layout changes dramatically (for example, if it includes non-int fields at the beginning).

Here's how you might do it:

void setValue(int custInd, int fieldOffset) {
    int *ptr = (int *)((char *)&customers[custInd] + fieldOffset);
    *ptr = 5;
}

...
setValue(custInd, offsetof(Customer, bottles));

offsetof is a standardized macro that returns the offset, in bytes, from the start of the structure to the given element.

If you still want to use indices, you can compute the offset as propertyInd * sizeof(int) , assuming every field in the struct is an int .

Answer 2

You can't do this:

*(&customers[custInd]+propertyInd) = 5;

because the type of &customers[custInd] is struct Customer* , not int * . So &customers[custInd]+propertyInd means the same thing as &customers + custInd + propertyInd or, in other words, &customers[custInd + propertyInd] . The assignment then attempts to set a structure value to the integer 5 , which is obviously illegal.

What I suppose you meant was

((int*)&customers[custInd])[propertyInd] = 5;

which would compile fine, and would probably work[*], but is undefined behaviour because you cannot assume that just because a struct consists of four int s, that it is laid-out in memory the same way as int[4] would be. It may seem reasonable and even logical that they layout be the same, but the standard doesn't require it, so that's that. Sorry.

As @iharob suggests in a comment, you might find a compiler clever enough to generate efficient code from the following verbiage:

void setValue(int custInd, int propertyInd, int value) {
  //propertyInd would be 1 for id, 2 for bottles
  switch (propertyInd) {
    case 1: customers[custInd].id = value; break;
    case 2: customers[custInd].bottles = value; break;
    case 3: customers[custInd].diapers = value; break;
    case 4: customers[custInd].rattles = value; break;
    default: assert(0);
  }
}

*: Actually, it would (probably) work if propertyInd for id were 0, not 1. C array indices start at 0.

Answer 3

&customers[custInd] is a pointer to customers[custInd] , so &customers[custInd]+propertyInd is a pointer to customers[custInd+propertyInd] . It is not a pointer to a member. It will have type pointer to Customer . The value of that pointer will be equal to &(customers[custInd+propertyInd].id) , but is not a pointer to int - hence the compiler error.

Your bigger problem is that four int in a struct are not necessarily laid out like an array of int - there may be padding between struct members. So, if we do

int *p = &(customers[custInd].id);

then p+1 is not necessarily equal to &(customers[custInd].bottles) .

So you will need to do something like

void setValue(int custInd, int Offset)
{
    int *ptr = (int *)(((char *)&customers[custInd]) + Offset);
    *ptr = 5;
}

/*  and to call it to set customers[custInd].bottles to 5 */

setValue(custInd, offsetof(Customer, bottles));