Namespaces
Variants

std:: is_constructible, std:: is_trivially_constructible, std:: is_nothrow_constructible

From cppreference.net
C++
Metaprogramming library
Type traits
Type categories
(C++11)
(C++11) ( DR* )
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type properties
(C++11)
(C++11)
(C++11)
(C++11)
(C++14)
(C++11)
(C++17)
(C++23)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
(C++11) ( until C++20* )
(C++11) (deprecated in C++20)
(C++11)
(C++11)
(C++20)
(C++20)
(C++23)
(C++17)
Type trait constants
(C++11) (C++17) (C++11) (C++11)
Metafunctions
(C++17)
(C++17)
(C++17)
Supported operations
Relationships and property queries
Type modifications
Type transformations
(C++11) (deprecated in C++23)
(C++11) (deprecated in C++23)
(C++11)
(C++20)
(C++11) ( until C++20* ) (C++17)

Compile-time rational arithmetic
Compile-time integer sequences
(C++14)
Défini dans l'en-tête <type_traits>
template < class T, class ... Args >
struct is_constructible ;
(1) (depuis C++11)
template < class T, class ... Args >
struct is_trivially_constructible ;
(2) (depuis C++11)
template < class T, class ... Args >
struct is_nothrow_constructible ;
(3) (depuis C++11)
1) Si T est un type objet ou référence et que la définition de variable T obj ( std:: declval < Args > ( ) ... ) ; est bien formée, fournit la constante membre value égale à true . Dans tous les autres cas, value est false .
Aux fins de cette vérification, la définition de variable n'est jamais interprétée comme une déclaration de fonction, et l'utilisation de std::declval n'est pas considérée comme une odr-use . Les vérifications d'accès sont effectuées comme si elles provenaient d'un contexte sans rapport avec T et l'un des types dans Args . Seule la validité du contexte immédiat de la définition de variable est prise en compte.
2) Identique à (1) , mais la définition de la variable n'appelle aucune opération qui n'est pas triviale. Aux fins de cette vérification, l'appel à std::declval est considéré comme trivial.
3) Identique à (1) , mais la définition de la variable est noexcept .

Si T ou tout type dans le pack de paramètres Args n'est pas un type complet, (éventuellement qualifié cv) void , ou un tableau de limite inconnue, le comportement est indéfini.

Si une instanciation d'un template ci-dessus dépend, directement ou indirectement, d'un type incomplet, et que cette instanciation pourrait produire un résultat différent si ce type était hypothétiquement complété, le comportement est indéfini.

Si le programme ajoute des spécialisations pour l'un des modèles décrits sur cette page, le comportement est indéfini.

Table des matières

Modèles de variables auxiliaires

template < class T, class ... Args >

inline constexpr bool is_constructible_v =

is_constructible < T, Args... > :: value ;
(depuis C++17)
template < class T, class ... Args >

inline constexpr bool is_trivially_constructible_v =

is_trivially_constructible < T, Args... > :: value ;
(depuis C++17)
template < class T, class ... Args >

inline constexpr bool is_nothrow_constructible_v =

is_nothrow_constructible < T, Args... > :: value ;
(depuis C++17)

Hérité de std:: integral_constant

Constantes membres

value
[static]
true si T est constructible à partir de Args... , false sinon
(constante membre publique statique)

Fonctions membres

operator bool
convertit l'objet en bool , retourne value
(fonction membre publique)
operator()
(C++14)
retourne value
(fonction membre publique)

Types membres

Type Définition
value_type bool
type std:: integral_constant < bool , value >

Notes

Dans de nombreuses implémentations, is_nothrow_constructible vérifie également si le destructeur lève des exceptions car il est effectivement noexcept ( T ( arg ) ) . La même chose s'applique à is_trivially_constructible , qui, dans ces implémentations, exige également que le destructeur soit trivial : Bug GCC 51452 LWG issue 2116 .

Exemple

Exécuter ce code 
#include <iostream>
#include <type_traits>
class Foo
{
    int v1;
    double v2;
public:
    Foo(int n) : v1(n), v2() {}
    Foo(int n, double f) noexcept : v1(n), v2(f) {}
};
int main()
{
    auto is = [](bool o) { return (o ? "\t" "is " : "\t" "isn't "); };
    std::cout << "Foo ...\n"
              << is(std::is_trivially_constructible_v<Foo, const Foo&>)
              << "Trivially-constructible from const Foo&\n"
              << is(std::is_trivially_constructible_v<Foo, int>)
              << "Trivially-constructible from int\n"
              << is(std::is_constructible_v<Foo, int>)
              << "Constructible from int\n"
              << is(std::is_nothrow_constructible_v<Foo, int>)
              << "Nothrow-constructible from int\n"
              << is(std::is_nothrow_constructible_v<Foo, int, double>)
              << "Nothrow-constructible from int and double\n";
}

Sortie : 

Foo ...
        is Trivially-constructible from const Foo&
        isn't Trivially-constructible from int
        is Constructible from int
        isn't Nothrow-constructible from int
        is Nothrow-constructible from int and double

Voir aussi

(C++11) (C++11) (C++11)
vérifie si un type a un constructeur par défaut
(modèle de classe)
(C++11) (C++11) (C++11)
vérifie si un type a un constructeur de copie
(modèle de classe)
(C++11) (C++11) (C++11)
vérifie si un type peut être construit à partir d'une référence rvalue
(modèle de classe)
(C++20)
spécifie qu'une variable du type peut être construite à partir ou liée à un ensemble de types d'arguments
(concept)