тетсра структура переменных

Question

Это может показаться очень простой вопрос, но я следующие структуры в C++:

struct SMessage 
{ 
    unsigned int id; 
    unsigned int payloadSize; 
    unsigned char data[100]; 
    unsigned char *data2; 
}; 

позволяет сказать, у меня есть две переменных типа SMessage (msg1, msg2) и я хочу тетср отдельных членов msg1 в msg2 (просьба не спрашивать почему!). Я понимаю, что копирование идентификатор и payLoadSize относительно прямой:

memcpy(&msg2.id, &msg1.id, sizeof(unsigned int)); 
memcpy(&msg2.payLoadSize, &msg2.payLoadSize, sizeof(unsigned int)); 

но для копирования данных [] мы должны сделать:

memcpy(&msg2.data, &msg1.data, 100*sizeof(unsigned char)); 

или

memcpy(msg2.data, msg2.data, 100*sizeof(unsigned int)) 

также будет работать, так как данные является объектом массива?

Как мы будем копировать данные элемента структуры2, который вместо этого объявлен как указатель?

Answer 1

Любая версия будет работать. Используя амперсанд (&), оператор явно принимает адрес массива, в то время как опускание амперсанда заставляет его неявно брать адрес массива. В итоге результат тот же.

Что еще более важно, это проще и менее подвержены ошибкам использовать SizeOf непосредственно на поле:

std::memcpy(msg2.data, msg1.data, sizeof(msg1.data)); 

Это позволяет избежать опечаток и, что более важно, если изменения размера поля вы не должны идти через ваши места поиска кода, которые вы использовали.

Что касается data2, то zwol в его ответе ниже правилен тем, что он зависит от того, что именно хранит данные2, или, точнее, кто «владеет» данными2 и как будет освобождена переменная. Возможно, вам захочется заглянуть в «мелкое» и «глубокое» копирование.

Answer 2

Тип выражения msg.data отличается от типа выражения &msg.data, но значения идентичны. Поскольку это C++, поведение очень четко указано в : вызов memcpy вызывает неявное преобразование обоих аргументов указателя в [const] void *, а результат этого преобразования «указывает на начало места хранения, в котором находится объект, как если это наиболее производный объект (а не подобъект базового класса) ". (В C эффект один и тот же, но стандартное менее понятно из-за того, что вы так говорите - вы должны вместе прочитать параграфы 1 и 7 раздела C99 6.3.2.3 и понимать, что memcpy ведет себя «как бы», он преобразует свои аргументы в указатели- к характеру-типа внутренне.)

data объявлен как

unsigned char data[100]; 

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

memcpy(msg2.data, msg1.data, sizeof msg1.data); 

memcpy(msg2.data, msg1.data, 100); 
memcpy(msg2.data, msg1.data, 100 * sizeof(unsigned char)); 

memcpy(&msg2.data, &msg1.data, sizeof msg1.data); 
memcpy(&msg2.data, &msg1.data, 100); 
memcpy(&msg2.data, &msg1.data, 100 * sizeof(unsigned char)); 

Однако

memcpy(msg2.data, msg1.data, 100 * sizeof(unsigned int)); 

НЕПРАВИЛЬНО; он копирует слишком много памяти.¹ Вот почему форма с sizeof является предпочтительным стилем; сложнее ошибиться в первом месте и не станет ошибочным, если изменение типа изменилось. ²

Также в качестве стиля я предпочитаю не писать & в этом контексте, потому что &[anything with an array type] почти всегда неправильно, поэтому его не следует писать таким образом, если это действительно не необходимо.

И вы должны знать, что sizeof(any sort of char) == 1по определению (C++ [expr.sizeof]/1). Мое личное, но широко распространенное мнение, что это означает, что sizeof(char) никогда не должно появляться в вашем коде.

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

---

¹ за исключением очень маловероятном случае, sizeof(unsigned char) == sizeof(unsigned int); это было верно в оригинальном Cray, и стандарты по-прежнему допускают возможность, но AFAIK ни один разработчик на самом деле не сделал этого за многие годы.

² Контраргумент: применяется sizeof к типу массива, что является рискованным, потому что типы массивов «распадаются» на типы указателей, если им предоставлена ​​малейшая возможность сделать это, поэтому снова было бы неправильно неправильно. В случае, если вы находитесь, хотя - копирование элементов структуры вручную - я думаю, что это менее опасно, чем альтернатива.

Answer 3

Ваши последние две цифры memcpy() s должны быть sizeof(msg1.data) не 100*sizeof(unsigned int) - их unsigned char s в любом случае!

Но последнее:

memcpy(msg2.data, msg2.data, 100*sizeof(unsigned int)); 

правильно. Если вы хотите использовать ранее один, использование:

memcpy(&msg2.data[0], &msg1.data[0], 100*sizeof(unsigned int)); 

Answer 4

Оба они не правы, потому что они будут вызывать вне диапазона доступа, если sizeof(unsigned int) больше sizeof(char).

Вы можете сделать что-либо один из

memcpy(&msg2.data, &msg1.data, sizeof(msg1.data)); // pass pointers to arrays 
memcpy(msg2.data, msg1.data, 100*sizeof(unsigned char)); // pass pointers to first elements of the arrays