Why use the address of the first element of the structure, not the structure?

Question

I just found another code base at work, where developers sequentially use the address of the first structs element when copying / comparing / setting, and not in the structure itself. Here is a simple example.

First enter the structure type:

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

Then there is a function that creates a copy of such a structure:

 void bar(foo_t *inp) { foo_t l; ... memcpy(&l.a, &inp->a, sizeof(foo_t)); ... } 

I myself would not write the memcpy call in this way, and I began with the suspicion that the original developers simply did not quite understand the pointers and structures in C. However, now I saw this in two unrelated code bases, without common developers, so I start to doubt myself .

Why use this style?

Answer 1

No one should do this. If you are rebuilding structural elements, you have problems.

Answer 2

Instead of this:

 memcpy(&l.a, &inp->a, sizeof(foo_t)); 

You can do it:

 memcpy(&l, inp, sizeof(foo_t)); 

While this can be dangerous and misleading, both statements actually do the same here that C ensures that there is no padding in front of the first element of the structure.

But it’s best to just copy the structure objects using a simple assignment operator:

 l = *inp; 

Why use this style?

My guess is ignorance or bad discipline.

Answer 3

There wouldn’t be. If you ever moved a into a structure or you inserted its elements (s), you introduced a memory error.

Answer 4

This code is unsafe because reordering the elements of a structure can cause memcpy gain access outside the structure if member a is not the first member.

However, it is possible that the members are deliberately ordered within the structure, and the programmer only wants to copy a subset of them, starting from member a and running to the end of the structure. In this case, the code can be made safe with the following change:

  memcpy(&l.a, &inp->a, sizeof(foo_t) - offsetof(foo_t, a)); 

Now members of the structure can be rearranged in any order, and this memcpy will never go beyond.

Answer 5

This is a very bad habit. For example, a structure may have, for example, another member. This is an insanely careless habit, and I am surprised to learn that someone will do it.

Others have already noted this; the one that bothers me is this:

 struct Foo rgFoo [3]; struct Foo *pfoo = &rgFoo [0]; 

instead

 struct Foo *pfoo = rgfoo; 

Why allocate an array by index and then accept the address again? This is already an address, the only difference is that pfoo is technically

 struct Foo *const, 

not

 struct Foo *. 

But I always saw the first one.

Answer 6

In fact, there is one legitimate precedent for this: building a class hierarchy.

When treating structures as instances of a class, the first member (i.e., offset 0) will usually be an instance of a supertype ... if a supertype exists. This allows simple movement to move between using a subtype and a supertype. Very useful.

Regarding Darren Stone, pay attention to the intention, this is expected when doing OO in C.

In any other case, I would suggest avoiding this pattern and accessing the element directly, for the reasons already indicated.