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

Defined in header `<type_traits>`
template< class T, class... Args > struct is_constructible;	(1)	(since C++11)
template< class T, class... Args > struct is_trivially_constructible;	(2)	(since C++11)
template< class T, class... Args > struct is_nothrow_constructible;	(3)	(since C++11)

1) If the expression T obj(arg1, arg2, ... argN); is well-formed, given declval<Args>()... as arguments, provides the member constant value equal true. Otherwise, value is false.

2) same as 1), but the constructor expression does not call any operation that is not trivial.

3) same as 1), but the constructor expression is noexcept.

Inherited from std::integral_constant

Member constants

value

[static]

true if T is constructible from Args... , false otherwise
(public static member constant)

Member functions

operator bool	converts the object to bool, returns `value` (public member function)
operator() (C++14)	returns `value` (public member function)

Member types

Type	Definition
`value_type`	`bool`
`type`	std::integral_constant<bool, value>

[edit] Example

Run this 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() {
    std::cout << "Foo is ...\n" << std::boolalpha
              << "\tTrivially-constructible from const Foo&? "
              << std::is_trivially_constructible<Foo, const Foo&>::value << '\n'
              << "\tTrivially-constructible from int? "
              << std::is_trivially_constructible<Foo, int>::value << '\n'
              << "\tConstructible from int? "
              << std::is_constructible<Foo, int>::value << '\n'
              << "\tNothrow-constructible from int? "
              << std::is_nothrow_constructible<Foo, int>::value << '\n'
              << "\tNothrow-constructible from int and double? "
              << std::is_nothrow_constructible<Foo, int, double>::value << '\n';
}

Output:

Foo is ...
        Trivially-constructible from const Foo&? true
        Trivially-constructible from int? false
        Constructible from int? true
        Nothrow-constructible from int? false
        Nothrow-constructible from int and double? true

[edit] See also

is_default_constructibleis_trivially_default_constructibleis_nothrow_default_constructible (C++11)(C++11)(C++11)	checks if a type has a default constructor (class template)
is_copy_constructibleis_trivially_copy_constructibleis_nothrow_copy_constructible (C++11)(C++11)(C++11)	checks if a type has a copy constructor (class template)
is_move_constructibleis_trivially_move_constructibleis_nothrow_move_constructible (C++11)(C++11)(C++11)	checks if a type has a move constructor (class template)
uses_allocator (C++11)	checks if the specified type supports uses-allocator construction (class template)
std::experimental::is_constructible_v (library fundamentals TS)	variable template alias of `std::is_constructible::value` (variable template)
std::experimental::is_trivially_constructible_v (library fundamentals TS)	variable template alias of `std::is_trivially_constructible::value` (variable template)
std::experimental::is_nothrow_constructible_v (library fundamentals TS)	variable template alias of `std::is_nothrow_constructible::value` (variable template)

Language
Standard library headers
Concepts
Utilities library
Strings library
Containers library
Algorithms library
Iterators library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Technical Specifications

Type support (basic types, RTTI, type traits)
Dynamic memory management
Error handling
Program utilities
Variadic functions
Date and time
Function objects
initializer_list (C++11)
bitset
hash (C++11)
Relational operators
rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=
Pairs and tuples
pair
tuple (C++11)
piecewise_construct_t (C++11)
piecewise_construct (C++11)
integer_sequence (C++14)
Swap, forward and move
swap
exchange (C++14)
forward (C++11)
move (C++11)
move_if_noexcept (C++11)
declval (C++11)