KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::memcpy en objectrepresentaties van triviaal kopieerbare typen

Leer wanneer het kopiëren van bytes in C++23 de waarde van een object behoudt en waarom dit niet werkt als algemene manier om objecten te kopiëren.

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

Syntax

#include <cstring>

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

std::memcpy(dest, src, count) uit <cstring> kopieert precies count bytes van de bron naar het doel. Beide pointers moeten geldig zijn en mogen geen nullpointers zijn, ook als count == 0. Het bronbereik moet leesbaar zijn en het doelbereik schrijfbaar. Buiten de grenzen kopiëren of overlappende bereiken gebruiken leidt tot ongedefinieerd gedrag, niet tot een foutmelding. Gebruik std::memmove bij overlap; de overige voorwaarden blijven gelden.

De objectrepresentatie van een volledig object van type T beslaat sizeof(T) bytes. De bits die de waarde coderen vormen de waarderepresentatie; de overige bits zijn opvulbits. Controleer voor een volledig objecttype T met std::is_trivially_copyable_v<T> uit <type_traits> of het triviaal kopieerbaar is. Deze type-eigenschap controleert geen pointers of geheugenbereiken.

Kopieer alle sizeof(T) bytes van een geïnitialiseerd object naar een ander schrijfbaar object waarvan de levensduur al is begonnen en dat hetzelfde triviaal kopieerbare type T heeft. Het doel krijgt dan de waarde van de bron. Geen van beide mag een mogelijk overlappend deelobject zijn: een basisklasse-deelobject of een niet-statisch datalid met [[no_unique_address]]. Je kunt de representatie van een geschikt object ook bewaren in een array van char, unsigned char of std::byte en de ongewijzigde bytes terugkopiëren naar datzelfde object.

In C++23 kan de bewerking vóór het kopiëren impliciet de levensduur starten van objecten van typen met een impliciete levensduur, in correct uitgelijnd doelgeheugen en voor zover dat gedefinieerd gedrag oplevert. Ze roept geen constructors aan en start zo ook niet de levensduur van deelobjecten waarvan het type geen impliciete levensduur heeft. Het resultaat van type void* wijst naar een geschikt aangemaakt object als dat er is; anders is het dest.

Kopieer een std::string met de kopieerconstructor of door toekenning, niet door zijn bytes te kopiëren. Het kopiëren van een pointerwaarde kopieert niet het object waarnaar die wijst. Door opvulbits kan std::memcmp gelijke waarden van elkaar onderscheiden; de geheugenindeling en bytevolgorde zijn implementatieafhankelijk, dus de ruwe representatie is geen overdraagbaar formaat. Decodeer en valideer onbetrouwbare gegevens volgens een vastgelegd formaat, in plaats van willekeurige bytes als een geldige T te behandelen.

Voorbeelden

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

Resultaat

copy: 7 42
restored: 7 42

`static_assert` controleert het type `Record`. Het programma kopieert de waarde naar `target` en herstelt daarna de oorspronkelijke waarde van `source` uit `saved`. Het toont de waarden van de dataleden, niet de ruwe bytes.

Gerelateerde lessen

  • C++ · Les 16 · Gevorderd · Versie: 3

Bronnen