# std::is_convertible, std::is_nothrow_convertible

From cppreference.com
< cpp‎ | types

Defined in header `<type_traits>` |  |
template< class From, class To > struct is_convertible; | (1) | (since C++11)
template< class From, class To > struct is_nothrow_convertible; | (2) | (since C++20)

1) If the imaginary function definition To test() { return std::declval<From>(); } is well-formed, (that is, either std::declval<From>() can be converted to `To` using implicit conversions, or both `From` and `To` are possibly cv-qualified `void`), provides the member constant `value` equal to true. Otherwise `value` is false. For the purposes of this check, the use of std::declval in the return statement is not considered an odr-use.
Access checks are performed as if from a context unrelated to either type. Only the validity of the immediate context of the expression in the return statement (including conversions to the return type) is considered.
2) Same as (1), but the conversion is also `noexcept`.

`From` and `To` shall each be a complete type, (possibly cv-qualified) void, or an array of unknown bound. Otherwise, the behavior is undefined.

If an instantiation of a template above depends, directly or indirectly, on an incomplete type, and that instantiation could yield a different result if that type were hypothetically completed, the behavior is undefined.

### Helper variable template

template< class From, class To > inline constexpr bool is_convertible_v = is_convertible<From, To>::value; |  | (since C++17)
template< class From, class To > inline constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<From, To>::value; |  | (since C++20)

## Inherited from std::integral_constant

### Member constants

value [static] | true if `From` is convertible to `To` , 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>

### Notes

Gives well-defined results for reference types, void types, array types, and function types.

### Example

Run this code

    #include <iostream>
    #include <type_traits>

    class E { public: template<class T> E(T&&) { } };

    int main()
    {
        class A {};
        class B : public A {};
        class C {};
        class D { public: operator C() { return c; }  C c; };

        bool b2a = std::is_convertible<B*, A*>::value;
        bool a2b = std::is_convertible<A*, B*>::value;
        bool b2c = std::is_convertible<B*, C*>::value;
        bool d2c = std::is_convertible<D, C>::value;

        // A Perfect Forwarding constructor make the class 'convert' from everything

        bool everything2e = std::is_convertible<A, E>::value; //< B, C, D, etc

        std::cout << std::boolalpha;

        std::cout << b2a << '\n';
        std::cout << a2b << '\n';
        std::cout << b2c << '\n';
        std::cout << d2c << '\n';
        std::cout << '\n';
        std::cout << everything2e << '\n';
    }

Output:

    true
    false
    false
    true

    true

### See also

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/types/is_convertible&oldid=106238"