CKTIS / C++
std::is_standard_layout — vérifier les types à disposition standard
std::is_standard_layout vérifie à la compilation si un type respecte les règles de disposition standard. std::is_standard_layout_v expose directement le même résultat sous forme de bool. Ce trait ne garantit ni l’absence de remplissage en mémoire ni un format binaire portable.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
// <type_traits> synopsis (provided by the standard library)
namespace std {
template<class T> struct is_standard_layout;
template<class T>
inline constexpr bool is_standard_layout_v = is_standard_layout<T>::value;
}L’en-tête <type_traits> fournit le modèle de classe std::is_standard_layout<T>. Son membre value est une constante de type bool : il vaut true lorsque T est un type à disposition standard. Le modèle de variable std::is_standard_layout_v<T> est une forme abrégée de std::is_standard_layout<T>::value, et non un alias de type. Les deux formes peuvent être utilisées dans static_assert et if constexpr.
Les types à disposition standard comprennent les types scalaires, les classes qui respectent certaines règles, les tableaux de tels types et leurs variantes qualifiées cv. Parmi les exigences applicables aux classes : aucune fonction virtuelle ni classe de base virtuelle, le même contrôle d’accès pour tous les membres de données non statiques, et aucun membre de données non statique de type référence ou de type classe sans disposition standard. Cette restriction de type ne s’applique pas aux membres de données statiques. L’héritage est soumis à des restrictions supplémentaires ; l’absence de fonctions virtuelles ne suffit pas à elle seule.
La précondition exige que std::remove_all_extents_t<T> soit un type complet ou un void éventuellement qualifié cv. Ne vérifiez pas une classe avant sa définition complète. Pour void, le résultat est false. N’ajoutez pas vos propres spécialisations de ces traits : cela entraîne un comportement indéfini.
La disposition standard et la copie triviale sont des propriétés distinctes. Un résultat true ne garantit ni l’absence d’octets de remplissage, ni une ABI identique, ni une sérialisation sûre par écriture d’octets bruts. Dans l’exemple, Point respecte les règles, tandis que Polymorphic ne les respecte pas à cause de sa fonction virtuelle ; la sortie attendue est true, puis false sur des lignes distinctes.
Exemples
#include <iostream>
#include <type_traits>
struct Point {
int x;
int y;
};
struct Polymorphic {
virtual void draw() {}
};
static_assert(std::is_standard_layout<Point>::value);
static_assert(std::is_standard_layout_v<Point>);
static_assert(!std::is_standard_layout_v<Polymorphic>);
int main() {
std::cout << std::boolalpha
<< std::is_standard_layout<Point>::value << '\n'
<< std::is_standard_layout_v<Polymorphic> << '\n';
}
Résultat
true false
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.