C++标准模板（STL）- 类型支持（杂项变换，确定一组类型的公共类型，std::common_type）

类型特性

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

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

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

杂项变换

确定一组类型的公共类型

std::common_type

template< class... T >
struct common_type;

(C++11 起)

确定所有类型 T... 的共用类型，即所有 T... 都能隐式转换到的类型。若这种类型（根据后述规则确定）存在，则成员 type 指名该类型。否则，无成员 type 。

若 sizeof...(T) 为零，则无成员 type 。
若 sizeof...(T) 为一（即 T... 只含一个类型 T0 ），则成员 type 指名与 std::common_type<T0, T0>::type 相同的类型，若它存在；否则无成员 type 。
若 sizeof...(T) 为二（即 T... 含恰好二个成员 T1 与 T2 ），则

若应用 std::decay 到至少 T1 与 T2 中至少一个类型后产生相异类型，则成员 type 指名与 std::common_type<std::decay<T1>::type, std::decay<T2>::type>::type 相同的类型，若它存在；若不存在，则无成员 type 。
否则，若有对 std::common_type<T1, T2> 的用户定义特化，则使用该特化；
否则，若 std::decay<decltype(false ? std::declval<T1>() : std::declval<T2>())>::type 是合法类型，则成员 type 代表该类型；

否则，若 std::decay<decltype(false ? std::declval<const T1 &>() : std::declval<const T2 &>())>::type 为合法类型，则成员 type 代表该类型；

(C++20 起)

否则，无成员 type 。

若 sizeof...(T) 大于二（即 T... 由类型 T1, T2, R... 组成），则若 std::common_type<T1, T2>::type 存在，则成员 type 指代 std::common_type<std::common_type<T1, T2>::type, R...>::type ，若存在这种类型。其他所有情况下，无成员 type 。

参数包 T 中的类型应均为完整类型、（可为 cv 限定的） void ，或未知边界数组。否则行为未定义。

若上述模板的实例化直接或间接地依赖于不完整类型，并且如果假如使该类型完整，实例化就会产生不同的结果，则行为未定义。

成员类型

名称	定义
`type`	所有 `T...` 的共用类型

辅助类型

template< class... T >
using common_type_t = typename common_type<T...>::type;

(C++14 起)

特化

用户可为类型 T1 与 T2 特化 common_type ，只要

T1 与 T2 至少一个依赖于用户定义类型，且
std::decay 对于 T1 和 T2 都是同等变换。

若这种特化拥有名为 type 的成员，则它必须是公开且无歧义的成员类型，并指名一个 T1 和 T2 都能显式转换到的，无 cv 限定且非引用的类型。而且， std::common_type<T1, T2>::type 与 std::common_type<T2, T1>::type 必须指代同一类型。

以违背这些规则的方式添加 common_type 特化的程序拥有未定义行为。

注意添加特化到来自 <type_traits> 的任何其他模板的行为是未定义的。

标准库已提供下列特化：

std::common_type<std::chrono::duration>	特化 std::common_type 特征 (类模板特化)
std::common_type<std::chrono::time_point>	特化 std::common_type 特征 (类模板特化)

可能的实现

// 初等模板（用于零个类型）
template <class ...T> struct common_type { }; 
 
 一个类型
template <class T>
struct common_type<T> {
    using type = typename common_type<T, T>::type;
};
 
 二个类型
 
// 二个类型的默认实现
template<class T1, class T2>
using cond_t = decltype(false ? std::declval<T1>() : std::declval<T2>());
 
template<class T1, class T2, class=void>
struct common_type_2_default { };
 
template<class T1, class T2>
struct common_type_2_default<T1, T2, std::void_t<cond_t<T1, T2>>> {
    using type = std::decay_t<cond_t<T1, T2>>;
};
 
// 退化应用特化前的类型的派发器
template<class T1, class T2, class D1 = std::decay_t<T1>, class D2=std::decay_t<T2>>
struct common_type_2_impl : common_type<D1, D2> {};
 
template<class D1, class D2>
struct common_type_2_impl<D1, D2, D1, D2> : common_type_2_default<D1, D2> {};
 
template <class T1, class T2>
struct common_type<T1, T2> : common_type_2_impl<T1, T2> { };
 
 3 个以上类型
 
template<class AlwaysVoid, class T1, class T2, class...R>
struct common_type_multi_impl { };
 
template< class T1, class T2, class...R>
struct common_type_multi_impl<std::void_t<common_type_t<T1, T2>>, T1, T2, R...>
    : common_type<common_type_t<T1, T2>, R...>  { };
 
 
template <class T1, class T2, class... R>
struct common_type<T1, T2, R...>
    : common_type_multi_impl<void, T1, T2, R...> { };

注意

对于不是提升目标的算术类型，共用类型可视为如 T0() + T1() + ... + Tn() 的（可以为混合模式的）算术表达式的类型。

调用示例

#include <iostream>
#include <type_traits>
#include <typeinfo>

struct C
{
};

struct A : C
{
};

struct B : C
{
};

int main()
{
    typedef typename std::common_type<int, double>::type Type1;
    typedef typename std::common_type<char, int>::type Type2;
    typedef typename std::common_type<std::string, char*>::type Type3;
    typedef typename std::common_type<bool, int>::type Type4;
    typedef typename std::common_type<bool, char>::type Type5;
    typedef typename std::common_type<char, double>::type Type6;
    typedef typename std::common_type<A, C, B>::type Type7;

    std::cout << "std::common_type<int, double>::type:          "
              << typeid(Type1).name() << std::endl;
    std::cout << "std::common_type<char, int>::type:            "
              << typeid(Type2).name() << std::endl;
    std::cout << "std::common_type<std::string,double>::type:   "
              << typeid(Type3).name() << std::endl;
    std::cout << "std::common_type<bool, int>::type:            "
              << typeid(Type4).name() << std::endl;
    std::cout << "std::common_type<bool, int>::type:            "
              << typeid(Type5).name() << std::endl;
    std::cout << "std::common_type<char, double>::type:         "
              << typeid(Type6).name() << std::endl;
    std::cout << "std::common_type<A, C, B>::type:              "
              << typeid(Type7).name() << std::endl;

    return 0;
}

输出

std::common_type<int, double>::type:          d
std::common_type<char, int>::type:            i
std::common_type<std::string,double>::type:   NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE
std::common_type<bool, int>::type:            i
std::common_type<bool, int>::type:            i
std::common_type<char, double>::type:         d
std::common_type<A, C, B>::type:              1C