Безопасно ли memcpy для динамической структуры хранения?

контекст:

я просматривал некоторый код, который получает данные из дескриптора ввода-вывода в символьный буфер, выполняет некоторый контроль над ним, а затем использует часть полученного буфера для заполнения структуры, и внезапно задался вопросом, Может ли быть задействовано строгое нарушение правила псевдонима.

вот упрощенная версия

#define BFSZ 1024
struct Elt {
   int id;
   ...
};

unsigned char buffer[BFSZ];
int sz = read(fd, buffer, sizeof(buffer)); // correctness control omitted for brievety

// search the beginning of struct data in the buffer, and process crc control
unsigned char *addr = locate_and_valid(buffer, sz);

struct Elt elt;

memcpy(&elt, addr, sizeof(elt)); // populates the struct

// and use it
int id = elt.id;
...

пока все хорошо. Предоставьте буфер, содержащий действительное представление структуры-скажем, он был создан на том же платформа, поэтому без endianness или проблемы заполнения -memcpy вызов заполнил структуру, и ее можно безопасно использовать.

если структура динамически выделяется, она не имеет объявленного типа. Давайте заменим последние строки на:

struct Elt *elt = malloc(sizeof(struct Element)); // no declared type here

memcpy(elt, addr, sizeof(*elt)); // populates the newly allocated memory and copies the effective type

// and use it
int id = elt->id;  // strict aliasing rule violation?
...

проект n1570 для языка C говорит в 6.5 выражениях §6

эффективным типом объекта для доступа к его сохраненному значению является объявленный тип объекта возражаю, если есть.87) если значение сохраняется в объект, не имеющий объявленного типа через lvalue, имеющий тип, который не является типом символа, тогда тип lvalue становится эффективный тип объекта для этого доступа и для последующих обращений, которые не изменяются сохраненное значение. если значение копируется в объект, не имеющий объявленного типа, используя memcpy или memmove, или копируется как массив символьного типа, а затем эффективный тип измененного объекта для этого доступа и для последующего доступы, которые не изменяют value-эффективный тип объекта, из которого копируется значение, если оно имеет значение.

buffer имеет эффективный тип и даже объявленный тип: это массив unsigned char. Именно по этой причине код использует memcpy вместо простого псевдонима вроде:

struct Elt *elt = (struct Elt *) addr;

что действительно было бы строгим нарушением правила сглаживания (и может дополнительно возникнуть с проблемами выравнивания). Но если ... --6--> дал эффективный тип беззнаковый char массив в зону указал elt, все потеряно.

вопрос:

тут memcpy от массива символьного типа к объекту без объявленного типа дают эффективный тип массива символов?

отказ от ответственности:

Я знаю, что он работает без предупреждения со всеми распространенными компиляторами. Я просто хочу знать, правильно ли мое понимание стандарта

для того, чтобы лучше покажите мою проблему, давайте рассмотрим другую структуру Elt2 с sizeof(struct Elt2)sizeof(struct Elt) и

struct Elt2 actual_elt2 = {...};

для статического или автоматического хранения я не могу повторно использовать память объекта:

struct Elt elt;
struct Elt2 *elt2 = &elt;
memcpy(elt2, &actual_elt2, sizeof(*elt2));
elt2->member = ...           // strict aliasing violation!

пока это нормально для динамического (вопрос об этом здесь):

struct Elt *elt = malloc(sizeof(*elt));
// use elt
...
struct Elt2 *elt2 = elt;
memcpy(elt2, &actual_elt2, sizeof(*elt2));
// ok, memory now have struct Elt2 effective type, and using elt would violate strict aliasing rule
elt2->member = ...;        // fine
elt->id = ...;             // strict aliasing rule violation!

что может сделать копирование из массива разных?