Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::memcpy e rappresentazione degli oggetti di tipo banalmente copiabile

Scopri quando copiare i byte preserva il valore di un oggetto in C++23 e perché questa garanzia non si estende a oggetti di qualsiasi tipo.

Versione: ISO C++23; implementation support may vary

Sintassi

#include <cstring>

// Call: destination first; count is in bytes.
std::memcpy(dest, src, count);

std::memcpy(dest, src, count), dichiarata in <cstring>, copia esattamente count byte dalla sorgente alla destinazione. Entrambi i puntatori devono essere validi e non nulli, anche se count == 0. L’intervallo sorgente deve essere leggibile e quello di destinazione scrivibile. La copia fuori dai limiti o tra intervalli sovrapposti causa comportamento indefinito, non una segnalazione d’errore. Se gli intervalli si sovrappongono, usa std::memmove; gli altri requisiti restano validi.

La rappresentazione di un oggetto completo di tipo T occupa sizeof(T) byte. I bit che codificano il valore formano la rappresentazione del valore; gli altri sono bit di riempimento. Per un tipo di oggetto completo T, verifica che sia banalmente copiabile con std::is_trivially_copyable_v<T> di <type_traits>. Questo tratto di tipo non controlla puntatori o intervalli.

Copiando tutti i sizeof(T) byte da un oggetto inizializzato in un altro oggetto dello stesso tipo banalmente copiabile T, già in vita e scrivibile, la destinazione acquisisce il valore della sorgente. Nessuno dei due può essere un sotto-oggetto potenzialmente sovrapposto: un sotto-oggetto di classe base o un membro dati non statico marcato con [[no_unique_address]]. Puoi anche salvare la rappresentazione di un oggetto idoneo in un array di char, unsigned char o std::byte e ripristinare i byte invariati nello stesso oggetto.

In C++23 l’operazione può far iniziare implicitamente, prima della copia, il tempo di vita di oggetti di tipi a tempo di vita implicito in memoria di destinazione opportunamente allineata, se così il comportamento è definito. Non invoca costruttori né avvia la vita di sotto-oggetti il cui tipo non è a tempo di vita implicito. Il risultato di tipo void* punta a un oggetto creato idoneo, se esiste; altrimenti vale dest.

Copia uno std::string tramite costruzione per copia o assegnazione, non copiandone i byte. Copiare il valore di un puntatore non copia l’oggetto puntato. I bit di riempimento possono far sì che std::memcmp distingua valori uguali; la disposizione in memoria e l’ordine dei byte dipendono dall’implementazione, dunque la rappresentazione grezza non è un formato portabile. Decodifica e convalida i dati non attendibili secondo un formato definito, anziché trattare byte arbitrari come un valore valido di tipo T.

Esempi

#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';
}

Risultato

copy: 7 42
restored: 7 42

`static_assert` verifica il tipo `Record`. Il programma copia il valore in `target`, poi ripristina il valore originale di `source` da `saved`. Stampa i valori dei membri, non i byte grezzi.

Lezioni correlate

  • C++ · Lezione 16 · Avanzato · Versione: 3

Fonti