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

CKTIS / C++

std::is_trivially_copyable — détecter les types à copie triviale

Ce trait de <type_traits> vérifie à la compilation si un type est à copie triviale. Découvrez les formes équivalentes ::value et _v, ainsi que les limites de la copie de la représentation d’un objet.

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

Syntaxe

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

std::is_trivially_copyable<T> de <type_traits> est un trait de type : son ::value est une constante booléenne qui indique si T est à copie triviale. std::is_trivially_copyable_v<T> donne directement la même valeur. Utilisez-le dans un static_assert ou un if constexpr pour vérifier les exigences du code générique.

Ces types comprennent les types scalaires, les classes à copie triviale, les tableaux de ces types et leurs variantes qualifiées cv. Une classe doit avoir au moins une opération de copie ou de déplacement admissible ; chacune de ces opérations admissibles doit être triviale, et son destructeur doit être trivial et non supprimé. Ce trait ne vérifie ni les propriétés de standard-layout ni simplement la possibilité d’appeler un constructeur de copie.

La précondition exige que std::remove_all_extents_t<T> soit un type complet ou void, éventuellement qualifié cv. Ne testez donc pas une classe avant sa définition complète. Dans l’exemple, Point satisfait le trait, contrairement à NonTrivial, en raison de son destructeur fourni par l’utilisateur.

Pour deux objets distincts et existants du même type à copie triviale, dont aucun n’est un sous-objet susceptible de chevauchement, copier toute la représentation avec std::memcpy donne à l’objet de destination la valeur de l’objet source, à condition que les plages d’octets source et destination ne se chevauchent pas. Même si les objets sont distincts, le chevauchement de ces plages entraîne un comportement indéfini lors de l’appel à std::memcpy. L’exemple copie ainsi Point. Toutefois, true ne signifie pas qu’il s’agit d’un format de sérialisation portable : la représentation peut contenir des octets de remplissage, et les pointeurs ne deviennent pas des copies des objets pointés. Les exigences relatives à la durée de vie des objets et à l’accès valide à la mémoire restent applicables.

Exemples

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

Résultat

true
3 7

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources