# std::is_convertible

From cppreference.com
< cpp‎ | types

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

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 conversion, 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 is 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.

`From` and `To` shall each be a complete type, (possibly cv-qualified) void, or an array of unknown bound. Otherwise, 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)

## 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>

    int main()
    {
        class A {};
        class B : public A {};
        class 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;

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

Output:

    true
    false
    false

### See also

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