std::common_type

在标头 `<type_traits>` 定义
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<CR1>() : std::declval<CR2>())>::type 是合法类型，其中 CR1 与 CR2 分别是 const std::remove_reference_t<T1>& 与 const std::remove_reference_t<T2>&，那么成员 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 的成员，那么限定标识 std::common_type<T1, T2>::type 必须合法并指名一个 T1 和 T2 都能显式转换到的，无 cv 限定且非引用的类型。而且，std::common_type<T1, T2>::type 与 std::common_type<T2, T1>::type 必须指代同一类型。

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

注意添加特化到来自 <type_traits> 的任何其他模板（除了 std::basic_common_reference） (C++20 起)的程序行为未定义。

标准库已提供下列特化：

std::common_type<std::chrono::duration> (C++11)	特化 std::common_type 特征 (类模板特化)
std::common_type<std::chrono::time_point> (C++11)	特化 std::common_type 特征 (类模板特化)
std::common_type<std::pair> (C++23)	确定两个 `pair` 的公共类型 (类模板特化)
std::common_type<tuple-like> (C++23)	确定 `tuple` 和 `tuple-like` 类型的公共类型 (类模板特化)
std::common_type<std::basic_const_iterator> (C++23)	确定迭代器和所适配的 `basic_const_iterator` 类型的公共类型 (类模板特化)

可能的实现

// 主模板（用于零个类型）
template<class...>
struct common_type {};
 
// 一个类型
template<class T>
struct common_type<T> : common_type<T, T> {};
 
namespace detail
{
    template<class...>
    using void_t = void;
 
    template<class T1, class T2>
    using conditional_result_t = decltype(false ? std::declval<T1>() : std::declval<T2>());
 
    template<class, class, class = void>
    struct decay_conditional_result {};
    template<class T1, class T2>
    struct decay_conditional_result<T1, T2, void_t<conditional_result_t<T1, T2>>>
        : std::decay<conditional_result_t<T1, T2>> {};
 
    template<class T1, class T2, class = void>
    struct common_type_2_impl : decay_conditional_result<const T1&, const T2&> {};
 
    // C++11 实现：
    // template<class, class, class = void>
    // struct common_type_2_impl {};
 
    template<class T1, class T2>
    struct common_type_2_impl<T1, T2, void_t<conditional_result_t<T1, T2>>>
        : decay_conditional_result<T1, T2> {};
}
 
// 两个类型
template<class T1, class T2>
struct common_type<T1, T2> 
    : std::conditional<std::is_same<T1, typename std::decay<T1>::type>::value &&
                       std::is_same<T2, typename std::decay<T2>::type>::value,
                       detail::common_type_2_impl<T1, T2>,
                       common_type<typename std::decay<T1>::type,
                                   typename std::decay<T2>::type>>::type {};
 
// 三个及以上类型
namespace detail
{
    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<void_t<typename common_type<T1, T2>::type>, T1, T2, R...>
        : common_type<typename common_type<T1, T2>::type, R...> {};
}
 
template<class T1, class T2, class... R>
struct common_type<T1, T2, R...>
    : detail::common_type_multi_impl<void, T1, T2, R...> {};

注解

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

示例

演示由程序定义的类上的混合模式算术：

运行此代码

#include <iostream>
#include <type_traits>
 
template<class T>
struct Number { T n; };
 
template<class T, class U>
constexpr Number<std::common_type_t<T, U>>
    operator+(const Number<T>& lhs, const Number<U>& rhs)
{
    return {lhs.n + rhs.n};
}
 
void describe(const char* expr, const Number<int>& x)
{
    std::cout << expr << "  是  Number<int>{" << x.n << "}\n";
}
 
void describe(const char* expr, const Number<double>& x)
{
    std::cout << expr << "  是  Number<double>{" << x.n << "}\n";
}
 
int main()
{
    Number<int> i1 = {1}, i2 = {2};
    Number<double> d1 = {2.3}, d2 = {3.5};
    describe("i1 + i2", i1 + i2);
    describe("i1 + d2", i1 + d2);
    describe("d1 + i2", d1 + i2);
    describe("d1 + d2", d1 + d2);
}

输出：

i1 + i2  是  Number<int>{3}
i1 + d2  是  Number<double>{4.5}
d1 + i2  是  Number<double>{4.3}
d1 + d2  是  Number<double>{5.8}

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

缺陷报告	应用于	出版时的行为	正确行为
LWG 2141	C++11	条件运算符的结果类型没有退化	退化结果类型
LWG 2408	C++11	`common_type` SFINAE 不友好	使之 SFINAE 友好
LWG 2460	C++11	几乎不可能写出 `common_type` 的特化	减少需要的特化数量

参阅

common_with

(C++20)

指定两个类型共有一个公共类型
(概念)

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏 (C++20)
语言支持库
概念库 (C++20)
元编程库 (C++11)
诊断库
通用工具库
字符串库
容器库
迭代器库
范围库 (C++20)
算法库
数值库
本地化库
输入/输出库
文件系统库 (C++17)
正则表达式库 (C++11)
并发支持库 (C++11)
技术规范
符号索引
外部库

std::common_type

成员类型

辅助类型

特化

可能的实现

注解

示例

缺陷报告

参阅

导航