C++标准模板（STL）- 类型支持 （类型关系，检查一个类型是否为另一类型的指针可互转换（起始）基类，std::is_pointer_interconvertible_base_of）

类型特性

类型特性定义一个编译时基于模板的结构，以查询或修改类型的属性。

试图特化定义于 <type_traits> 头文件的模板导致未定义行为，除了 std::common_type 可依照其所描述特化。

定义于<type_traits>头文件的模板可以用不完整类型实例化，除非另外有指定，尽管通常禁止以不完整类型实例化标准库模板。

受支持操作

检查一个类型是否为另一类型的指针可互转换（起始）基类

std::is_pointer_interconvertible_base_of

template< class Base, class Derived > struct is_pointer_interconvertible_base_of;

(C++20 起)

如果 Derived 无歧义地派生自 Base 且每个 Derived 对象均与其 Base 子对象指针可互转换，或它们均为相同的非联合类类型（两种情况下都忽略 cv 限定），那么提供的成员常量 value 等于 true。否则，value 等于 false。

如果 Base 与 Derived 均为非联合类类型且不是同一类型（忽略 cv 限定），那么 Derived 应当为完整类型；否则行为未定义。

如果程序添加了 std::is_pointer_interconvertible_base_of 或 std::is_pointer_interconvertible_base_of_v 的特化，那么行为未定义。

 辅助变量模板

template< class Base, class Derived > inline constexpr bool is_pointer_interconvertible_base_of_v =     is_pointer_interconvertible_base_of<Base, Derived>::value;

(C++20 起)

继承自 std::integral_constant

成员常量

value [静态]

如果 Derived 无歧义地派生自 Base 且每个 Derived 对象均与其 Base 子对象指针可互转换，或它们均为相同的非联合类类型（两种情况下都忽略 cv 限定）那么是 true，否则是 false (公开静态成员常量)

成员函数

operator bool	将对象转换到 bool，返回 value (公开成员函数)
operator() (C++14)	返回 value (公开成员函数)

成员类型

类型	定义
value_type	bool
type	std::integral_constant<bool, value>

注解

即使 T 为 U 的私有或受保护基类，std::is_pointer_interconvertible_base_of_v<T, U> 亦可以为 true。

令

• U 为完整对象类型，
• T 为 cv 限定不少于 U 的完整对象类型，
• u 为任何合法的 U 左值，

若 std::is_pointer_interconvertible_base_of_v<T, U> 为 true，则 reinterpret_cast<T&>(u) 始终有良定义的结果。

若 T 与 U 不是同一类型（忽略 cv 限定）且 T 为 U 的指针可互转换基类，则 std::is_standard_layout_v<T> 与 std::is_standard_layout_v<U> 均为 true。

若 T 为标准布局类类型，则 T 的所有基类（若存在）均为 T 的指针可互转换基类。

功能特性测试宏	值	标准	功能特性
__cpp_lib_is_pointer_interconvertible	201907L	(C++20)	指针可互换性特征： std::is_pointer_interconvertible_base_of std::is_pointer_interconvertible_with_class

调用示例

#include <iostream>
#include <type_traits>

namespace std
{

template <typename Base, typename Derived>
struct is_pointer_interconvertible_base_of
{
    static constexpr bool value = std::is_convertible<Base*, Derived*>::value &&
                                  std::is_convertible<Derived*, Base*>::value;
};

template< class Base, class Derived >
const bool is_pointer_interconvertible_base_of_v =
    is_pointer_interconvertible_base_of<Base, Derived>::value;
}


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

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

int main()
{
    std::cout << std::boolalpha;

    std::cout << "std::is_convertible<A, B>::value:             "
              << std::is_convertible<A, B>::value << std::endl;
    std::cout << "std::is_convertible<B, A>::value:             "
              << std::is_convertible<B, A>::value << std::endl;
    std::cout << "std::is_convertible<B*, A*>::value:           "
              << std::is_convertible<B*, A*>::value << std::endl;
    std::cout << "std::is_convertible<A*, B*>::value:           "
              << std::is_convertible<A*, B*>::value << std::endl;
    std::cout << "std::is_convertible<B*, C*>::value:           "
              << std::is_convertible<B*, C*>::value << std::endl;
    std::cout << "std::is_convertible<D, C>::value:             "
              << std::is_convertible<D, C>::value << std::endl;
    std::cout << "std::is_convertible<E, A>::value:             "
              << std::is_convertible<E, A>::value << std::endl;
    std::cout << "std::is_convertible<int, double>::value:      "
              << std::is_convertible<int, double>::value << std::endl;
    std::cout << "std::is_convertible<int, int>::value:         "
              << std::is_convertible<int, int>::value << std::endl;
    std::cout << "std::is_convertible<int, char>::value:        "
              << std::is_convertible<int, char>::value << std::endl;
    std::cout << "std::is_convertible<std::string, char>::value:"
              << std::is_convertible<std::string, char>::value << std::endl;

    std::cout << "-----------------------------------------------" << std::endl;
    std::cout << std::endl;

    std::cout << "std::is_pointer_interconvertible_base_of<A, B>::value:             "
              << std::is_pointer_interconvertible_base_of<A, B>::value << std::endl;
    std::cout << "std::is_pointer_interconvertible_base_of<B, A>::value:             "
              << std::is_pointer_interconvertible_base_of<B, A>::value << std::endl;
    std::cout << "std::is_pointer_interconvertible_base_of<B*, A*>::value:           "
              << std::is_pointer_interconvertible_base_of<B*, A*>::value << std::endl;
    std::cout << "std::is_pointer_interconvertible_base_of<A*, B*>::value:           "
              << std::is_pointer_interconvertible_base_of<A*, B*>::value << std::endl;
    std::cout << "std::is_pointer_interconvertible_base_of<B*, C*>::value:           "
              << std::is_pointer_interconvertible_base_of<B*, C*>::value << std::endl;
    std::cout << "std::is_pointer_interconvertible_base_of<D, C>::value:             "
              << std::is_pointer_interconvertible_base_of<D, C>::value << std::endl;
    std::cout << "std::is_pointer_interconvertible_base_of<E, A>::value:             "
              << std::is_pointer_interconvertible_base_of<E, A>::value << std::endl;
    std::cout << "std::is_pointer_interconvertible_base_of<int, double>::value:      "
              << std::is_pointer_interconvertible_base_of<int, double>::value << std::endl;
    std::cout << "std::is_pointer_interconvertible_base_of<int, int>::value:         "
              << std::is_pointer_interconvertible_base_of<int, int>::value << std::endl;
    std::cout << "std::is_pointer_interconvertible_base_of<int, char>::value:        "
              << std::is_pointer_interconvertible_base_of<int, char>::value << std::endl;
    std::cout << "std::is_pointer_interconvertible_base_of<std::string, char>::value:"
              << std::is_pointer_interconvertible_base_of<std::string, char>::value << std::endl;

    std::cout << "-----------------------------------------------" << std::endl;
    std::cout << std::endl;

    return 0;
}

输出

std::is_convertible<A, B>::value:             false
std::is_convertible<B, A>::value:             true
std::is_convertible<B*, A*>::value:           true
std::is_convertible<A*, B*>::value:           false
std::is_convertible<B*, C*>::value:           false
std::is_convertible<D, C>::value:             true
std::is_convertible<E, A>::value:             false
std::is_convertible<int, double>::value:      true
std::is_convertible<int, int>::value:         true
std::is_convertible<int, char>::value:        true
std::is_convertible<std::string, char>::value:false
-----------------------------------------------

std::is_pointer_interconvertible_base_of<A, B>::value:             false
std::is_pointer_interconvertible_base_of<B, A>::value:             false
std::is_pointer_interconvertible_base_of<B*, A*>::value:           false
std::is_pointer_interconvertible_base_of<A*, B*>::value:           false
std::is_pointer_interconvertible_base_of<B*, C*>::value:           false
std::is_pointer_interconvertible_base_of<D, C>::value:             false
std::is_pointer_interconvertible_base_of<E, A>::value:             false
std::is_pointer_interconvertible_base_of<int, double>::value:      false
std::is_pointer_interconvertible_base_of<int, int>::value:         true
std::is_pointer_interconvertible_base_of<int, char>::value:        false
std::is_pointer_interconvertible_base_of<std::string, char>::value:false
-----------------------------------------------