¿Por qué usar la dirección del primer elemento de la estructura, en lugar de la estructura misma?

Acabo de encontrar otra base de código en el trabajo donde los desarrolladores usan constantemente la dirección del primer elemento de las estructuras al copiar/comparar/configurar, en lugar de la estructura en sí. Aquí hay un ejemplo simple.

Primero hay un tipo de estructura:

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

Luego hay una función que hace una copia de tal estructura:

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

Yo mismo no escribiría una llamada a memcpy de esa manera y comencé sospechando que los desarrolladores originales simplemente no entendieron bien los punteros y las estructuras en C. Sin embargo, ahora he visto esto en dos bases de código no relacionadas, sin desarrolladores comunes, así que estoy empezando a dudar. mí mismo.

¿Por qué uno querría usar este estilo?

En lugar de eso:

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

usted puede hacer eso:

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

Si bien puede ser peligroso y engañoso, ambas declaraciones en realidad hacen lo mismo aquí, ya que C garantiza que no hay relleno antes del primer miembro de la estructura.

Pero lo mejor es simplemente copiar los objetos de estructura usando un operador de asignación simple:

l = *inp;

¿Por qué uno querría usar este estilo?

Mi conjetura: ignorancia o mala disciplina.

Nadie debería hacer eso. Si reorganiza los miembros de la estructura, está en problemas.

Uno no lo haría. Si alguna vez te mudaste a en la estructura o insertaste miembros antes, introducirías un error de destrucción de memoria.

Este código no es seguro porque reorganizar los miembros de la estructura puede resultar en la memcpy acceder más allá de los límites de la estructura si el miembro a ya no es el primer miembro.

Sin embargo, es concebible que los miembros estén ordenados intencionalmente dentro de la estructura y el programador solo quiera copiar un subconjunto de ellos, comienzo con miembro a y corriendo hasta el final de la estructura. Si ese es el caso, entonces el código se puede hacer seguro con el siguiente cambio:

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

Ahora los miembros de la estructura se pueden reorganizar en cualquier orden y esto memcpy nunca saldrá de los límites.

En realidad, hay un caso de uso legítimo para esto: construir una jerarquía de clases.

Cuando se tratan las estructuras como instancias de una clase, el primer miembro (es decir, el desplazamiento 0) normalmente será la instancia del supertipo… si existe un supertipo. Esto permite que un elenco simple se mueva entre el uso del subtipo y el supertipo. Muy útil.

En la nota de Darren Stone sobre la intención, esto es esperado al ejecutar OO en el lenguaje C.

En cualquier otro casosugeriría evitar este patrón y acceder directamente al miembro, por las razones ya citadas.

Es un muy mal hábito. La estructura podría tener otro miembro antepuesto, por ejemplo. Este es un hábito increíblemente descuidado y me sorprende leer que alguien haría esto.

Otros ya lo han notado; el que me jode es este:

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

en vez de

struct Foo *pfoo = rgfoo;

¿Por qué eliminar la referencia de la matriz por índice y luego tomar la dirección nuevamente? Ya es la direccion, la unica diferencia a destacar es que pfoo es tecnicamente

struct Foo *const, 

no

struct Foo *.  

Sin embargo, solía ver el primero todo el tiempo.