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)
Определено в заголовочном файле <type_traits>
template < class T, class ... Args >
struct is_constructible ;
(1) (начиная с C++11)
template < class T, class ... Args >
struct is_trivially_constructible ;
(2) (начиная с C++11)
template < class T, class ... Args >
struct is_nothrow_constructible ;
(3) (начиная с C++11)
1) Если T является объектным типом или типом ссылки, и определение переменной T obj ( std:: declval < Args > ( ) ... ) ; является корректным, предоставляет константу-член value равную true . Во всех остальных случаях value равна false .
Для целей данной проверки определение переменной никогда не интерпретируется как объявление функции, а использование std::declval не считается odr-использованием . Проверки доступа выполняются так, как если бы они производились из контекста, не связанного с T и любыми типами в Args . Учитывается только валидность непосредственного контекста определения переменной.
2) То же, что и (1) , но определение переменной не вызывает никаких операций, которые не являются тривиальными. Для целей данной проверки вызов std::declval считается тривиальным.
3) То же, что и (1) , но определение переменной является noexcept .

Если T или любой тип в пакете параметров Args не является полным типом, (возможно, cv-квалифицированным) void , или массивом неизвестной границы, поведение не определено.

Если создание экземпляра шаблона выше зависит, прямо или косвенно, от неполного типа, и это создание экземпляра может дать другой результат, если бы этот тип был гипотетически завершен, поведение не определено.

Если программа добавляет специализации для любых шаблонов, описанных на этой странице, поведение не определено.

Содержание

Вспомогательные шаблоны переменных

template < class T, class ... Args >

inline constexpr bool is_constructible_v =

is_constructible < T, Args... > :: value ;
(начиная с C++17)
template < class T, class ... Args >

inline constexpr bool is_trivially_constructible_v =

is_trivially_constructible < T, Args... > :: value ;
(начиная с C++17)
template < class T, class ... Args >

inline constexpr bool is_nothrow_constructible_v =

is_nothrow_constructible < T, Args... > :: value ;
(начиная с C++17)

Наследуется от std:: integral_constant

Константы-члены

value
[static]
true если T конструируем из Args... , false в противном случае
(публичная статическая константа-член)

Функции-члены

operator bool
преобразует объект в bool , возвращает value
(публичная функция-член)
operator()
(C++14)
возвращает value
(публичная функция-член)

Типы-члены

Тип Определение
value_type bool
type std:: integral_constant < bool , value >

Примечания

Во многих реализациях is_nothrow_constructible также проверяет, выбрасывает ли деструктор исключения, поскольку это фактически noexcept ( T ( arg ) ) . То же относится и к is_trivially_constructible , который в этих реализациях также требует, чтобы деструктор был тривиальным: GCC bug 51452 LWG issue 2116 .

Пример

Запустить этот код 
#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";
}

Вывод: 

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

Смотрите также

(C++11) (C++11) (C++11)
проверяет, имеет ли тип конструктор по умолчанию
(шаблон класса)
(C++11) (C++11) (C++11)
проверяет, имеет ли тип конструктор копирования
(шаблон класса)
(C++11) (C++11) (C++11)
проверяет, может ли тип быть сконструирован из rvalue-ссылки
(шаблон класса)
(C++20)
указывает, что переменная типа может быть сконструирована из или связана с набором типов аргументов
(концепт)