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.