CKTIS / C++
std::memcpy y la representación de objetos de tipos trivialmente copiables
Aprende cuándo copiar bytes conserva el valor de un objeto en C++23 y por qué eso no equivale a copiar objetos de cualquier tipo.
Versión: ISO C++23; implementation support may vary
Sintaxis
#include <cstring>
// Call: destination first; count is in bytes.
std::memcpy(dest, src, count);std::memcpy(dest, src, count), de <cstring>, copia exactamente count bytes del origen al destino. Ambos punteros deben ser válidos y no nulos, incluso si count == 0. El rango de origen debe permitir la lectura y el de destino, la escritura. Salirse de los límites o usar rangos solapados provoca comportamiento indefinido, no un aviso de error. Para rangos solapados, usa std::memmove; los demás requisitos siguen vigentes.
La representación de un objeto completo de tipo T ocupa sizeof(T) bytes. Los bits que codifican el valor forman la representación del valor; el resto son bits de relleno. Si T es un tipo de objeto completo, puedes comprobar si es trivialmente copiable con std::is_trivially_copyable_v<T> de <type_traits>. Este rasgo de tipo no comprueba los punteros ni los rangos.
Si copias los sizeof(T) bytes de un objeto inicializado a otro objeto del mismo tipo trivialmente copiable T, ya vivo y en el que se puede escribir, el destino adquiere el valor del origen. Ninguno puede ser un subobjeto potencialmente solapado: un subobjeto de clase base o un miembro de datos no estático marcado con [[no_unique_address]]. También puedes guardar la representación de un objeto que cumpla estas condiciones en un array de char, unsigned char o std::byte y restaurar los bytes sin cambios en ese mismo objeto.
En C++23, antes de copiar, la operación puede iniciar implícitamente la vida de objetos de tipos de vida implícita en memoria de destino con la alineación adecuada, si así se obtiene un comportamiento definido. No llama a constructores ni inicia la vida de subobjetos cuyos tipos no sean de vida implícita. El resultado de tipo void* apunta a un objeto creado adecuado, si lo hay; de lo contrario, es dest.
Para copiar un std::string, usa el constructor de copia o la asignación, no una copia de sus bytes. Copiar el valor de un puntero no copia el objeto al que apunta. El relleno puede hacer que std::memcmp distinga valores iguales, y la disposición en memoria y el orden de los bytes dependen de la implementación, por lo que la representación en bruto no es un formato portable. Decodifica y valida los datos no fiables según un formato definido, en lugar de tratar bytes arbitrarios como un valor válido de tipo T.
Ejemplos
#include <cstddef>
#include <cstring>
#include <iostream>
#include <type_traits>
struct Record {
int id;
int score;
};
static_assert(std::is_trivially_copyable_v<Record>);
int main() {
Record source{7, 42};
Record target{};
std::memcpy(&target, &source, sizeof(Record));
std::cout << "copy: " << target.id << ' ' << target.score << '\n';
std::byte saved[sizeof(Record)];
std::memcpy(saved, &source, sizeof(Record));
source = Record{0, 0};
std::memcpy(&source, saved, sizeof(Record));
std::cout << "restored: " << source.id << ' ' << source.score << '\n';
}Resultado
copy: 7 42 restored: 7 42
`static_assert` comprueba el tipo `Record`. El programa copia el valor en `target` y luego recupera el valor original de `source` desde `saved`. Imprime los valores de los miembros, no los bytes en bruto.
Lecciones relacionadas
- C++ · Lección 16 · Avanzado · Versión: 3