Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::memcpy et la représentation des objets de types trivialement copiables

Découvrez quand la copie d’octets préserve la valeur d’un objet en C++23 et pourquoi elle ne remplace pas la copie d’objets de types arbitraires.

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

Syntaxe

#include <cstring>

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

std::memcpy(dest, src, count), déclarée dans <cstring>, copie exactement count octets de la source vers la destination. Les deux pointeurs doivent être valides et non nuls, même si count == 0. La zone source doit être lisible et la zone de destination accessible en écriture. Un dépassement de limites ou un chevauchement entraîne un comportement indéfini, pas un signalement d’erreur. En cas de chevauchement, utilisez std::memmove ; les autres conditions restent valables.

La représentation d’un objet complet de type T occupe sizeof(T) octets. Les bits qui codent la valeur forment la représentation de la valeur ; les autres sont des bits de remplissage. Pour un type objet complet T, vérifiez qu’il est trivialement copiable avec std::is_trivially_copyable_v<T> de <type_traits>. Ce trait ne vérifie ni les pointeurs ni les plages mémoire.

Si vous copiez les sizeof(T) octets d’un objet initialisé vers un autre objet du même type trivialement copiable T, déjà vivant et accessible en écriture, la destination prend la valeur de la source. Aucun des deux objets ne doit être un sous-objet potentiellement chevauchant : un sous-objet de classe de base ou un membre de données non statique marqué [[no_unique_address]]. Vous pouvez aussi sauvegarder la représentation d’un tel objet dans un tableau de char, unsigned char ou std::byte, puis recopier les octets inchangés dans ce même objet.

En C++23, avant la copie, l’opération peut faire commencer implicitement la durée de vie d’objets de types à durée de vie implicite dans une zone de destination correctement alignée, si cela permet un comportement défini. Elle n’appelle aucun constructeur et ne démarre pas la durée de vie des sous-objets dont le type n’est pas à durée de vie implicite. Le résultat de type void* pointe vers un objet créé approprié s’il en existe un ; sinon, il vaut dest.

Copiez un std::string par construction de copie ou affectation, pas en copiant ses octets. Copier la valeur d’un pointeur ne copie pas l’objet pointé. À cause du remplissage, std::memcmp peut distinguer des valeurs égales ; la disposition en mémoire et l’ordre des octets dépendent de l’implémentation, ce qui exclut d’utiliser la représentation brute comme format portable. Décodez et validez les données non fiables selon un format défini, au lieu de traiter des octets arbitraires comme une valeur valide de type T.

Exemples

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

Résultat

copy: 7 42
restored: 7 42

`static_assert` vérifie le type `Record`. Le programme copie la valeur dans `target`, puis rétablit la valeur initiale de `source` à partir de `saved`. Il affiche les valeurs des membres, pas les octets bruts.

Leçons associées

  • C++ · Leçon 16 · Avancé · Version : 3

Sources