KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::is_trivially_copyable — triviaal kopieerbare typen herkennen

Deze trait uit <type_traits> controleert tijdens het compileren of een type triviaal kopieerbaar is. Leer de gelijkwaardige vormen ::value en _v kennen, evenals de beperkingen van het kopiëren van een objectrepresentatie.

Versie: C++23; repository compiler flag, production runtime not attested

Syntax

#include <type_traits>
std::is_trivially_copyable<T>::value
std::is_trivially_copyable_v<T>

std::is_trivially_copyable<T> uit <type_traits> is een type-trait: de ::value is een booleaanse constante die aangeeft of T triviaal kopieerbaar is. std::is_trivially_copyable_v<T> geeft dezelfde waarde rechtstreeks. Gebruik deze in static_assert of if constexpr om vereisten in generieke code te controleren.

Deze typen omvatten scalaire typen, triviaal kopieerbare klassen, arrays van zulke typen en hun cv-gekwalificeerde varianten. Een klasse moet ten minste één geschikte kopieer- of verplaatsingsbewerking hebben; elke dergelijke geschikte bewerking moet triviaal zijn en de destructor moet triviaal en niet verwijderd zijn. Dit controleert geen standard-layout-eigenschappen en evenmin alleen of een kopieerconstructor kan worden aangeroepen.

De voorwaarde vereist dat std::remove_all_extents_t<T> een volledig type is, of eventueel cv-gekwalificeerd void. Controleer een klasse dus niet voordat de volledige definitie beschikbaar is. In het voorbeeld voldoet Point aan de trait, maar NonTrivial niet, vanwege de door de gebruiker geleverde destructor.

Voor twee verschillende, bestaande objecten van hetzelfde triviaal kopieerbare type, waarvan geen van beide een mogelijk overlappend subobject is, krijgt het doelobject bij het kopiëren van de volledige representatie met std::memcpy de waarde van het bronobject, mits de bytebereiken van bron en doel elkaar niet overlappen. Ook bij verschillende objecten leidt overlap tussen die bytebereiken tot ongedefinieerd gedrag bij de aanroep van std::memcpy. Het voorbeeld kopieert Point op deze manier. true betekent echter niet dat er sprake is van een portable serialisatieformaat: de representatie kan opvulbytes bevatten en pointers worden geen kopieën van de objecten waarnaar ze verwijzen. De vereisten voor de levensduur van objecten en geldige geheugentoegang blijven gelden.

Voorbeelden

#include <cstring>
#include <iostream>
#include <type_traits>

struct Point {
    int x;
    int y;
};

struct NonTrivial {
    ~NonTrivial() {}
};

static_assert(std::is_trivially_copyable<Point>::value);
static_assert(!std::is_trivially_copyable_v<NonTrivial>);

int main() {
    Point source{3, 7};
    Point destination{0, 0};
    std::memcpy(&destination, &source, sizeof source);

    std::cout << std::boolalpha
              << std::is_trivially_copyable_v<Point> << '\n'
              << destination.x << ' ' << destination.y << '\n';
}

Resultaat

true
3 7

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen