C 结构中的跳过偏移量

Question

When I write a struct I want that specific value will be into specific offset

struct test

{
   int dummy1[100];//dummy
   int id_s ;
   int dummy2[5];//dummy
   int id_t;

}

What I want from this struct only 2 members: id_s and id_t , and I want that id_s will be in offset of 400 (100 * 4) and id_t will be in offset of (100 * 4 +4 + 5*4)

Is there any simple way to do that instead put some dummy fields?

Answer 1

Is there any simple way to do that instead put some dummy fields?

As a general portable solution: No

The C standard does not require the type int to be 4 bytes. Further, the C standard allows for padding in structs so that may also change layout. So you can't just write a struct like yours and rely on the offsets being what you want on all systems.

But for most systems it will work as you expect.

I would however do two changes.

1. Use char for dummies.

Like:

struct test
{
   char dummy1[400];//dummy
   int id_s ;
   char dummy2[20];//dummy
   int id_t;

};

2. Make the struct packed.

Like:

struct test
{
   char dummy1[400];//dummy
   int id_s ;
   char dummy2[20];//dummy
   int id_t;

} __attribute__((__packed__));

As you can't be 100% sure that it work, I would also add asserts (static) that veirifies that the layout is as expected.

Like:

_Static_assert(offsetof(struct test, id_s) == 400, "Illegal offset for id_s in struct test");
_Static_assert(offsetof(struct test, id_t) == 424, "Illegal offset for id_t in struct test");

To take the integer size in to account and still get the offsets 400 and 424, you could do:

struct test
{
   char dummy1[400];//dummy
   int id_s ;
   char dummy2[24 - sizeof(int)];//dummy
   int id_t;

} __attribute__((__packed__));

Answer 2

Is there any simple way to do that instead put some dummy fields?

Write your own accessors.

What I want from this struct only 2 members: id_s and id_t, and I want that id_s will be in offset of 400 (100 * 4) and id_t will be in offset of (100 * 4 +4 + 5*4)

Place them at specific byte-offsets yourself:

#define TEST_ID_S_OFFSET  (100*4)
// 100*4 +4 ? Why +4?
#define TEST_ID_T_OFFSET  (TEST_ID_S_OFFSET + sizeof(int) + 5*4)
struct test {
   char data[TEST_ID_T_OFFSET + sizeof(int)];
};

int test_get_id_s(struct test *t) {
      int ret;
      memcpy(&ret, &t->data[TEST_ID_S_OFFSET], sizeof(ret));
      return ret;
}
void test_set_id_s(struct test *t, int val) {
      memcpy(&t->data[TEST_ID_S_OFFSET], &val, sizeof(val));
}
int test_get_id_t(struct test *t) {
      int ret;
      memcpy(&ret, &t->data[TEST_ID_T_OFFSET], sizeof(ret));
      return ret;
}
void test_set_id_s(struct test *t, int val) {
      memcpy(&t->data[TEST_ID_T_OFFSET], &val, sizeof(val));
}