命名空间
变体
操作

std::common_type

来自 cppreference.cn
< cpp‎ | types
 
C++
 
元编程库
类型特征
类型类别
(C++11)
(C++11)(DR*)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11) 
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)  
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
类型属性
(C++11)
(C++11)
(C++11)
(C++11)
(C++14)
(C++11)
(C++17)
(C++23)
(C++11)(deprecated in C++26)
(C++11)
(C++11)
(C++11)(until C++20*)
(C++11)(deprecated in C++20)
(C++11)
(C++11)
(C++20)
(C++20)
(C++23)
(C++17)
类型特征常量
(C++11)(C++17)(C++11)(C++11)
元函数
(C++17)
(C++17)
(C++17)
支持的操作
关系和属性查询
类型修改
(C++11)(C++11)(C++11)
(C++11)(C++11)(C++11)
(C++11)
(C++11)
类型转换
(C++11)(deprecated in C++23)
(C++11)(deprecated in C++23)
(C++11)
(C++20)
(C++11)(until C++20*)(C++17)

(C++11)
common_type
(C++11)
(C++20)
(C++11)
(C++20)
(C++11)
(C++17)
编译时有理算术
编译时整数序列
(C++14)
 
定义于头文件 <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），
  • 如果对 T1 和 T2 中的至少一个应用 std::decay 产生不同的类型，则成员 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 表示该类型，参见 条件运算符；
 (C++20 起)
  • 否则，没有成员 type。
  • 如果 sizeof...(T) 大于二（即，T... 由类型 T1, T2, R... 组成），则如果 std::common_type<T1, T2>::type 存在，则成员 type 表示 std::common_type<typename 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 的成员，则它必须是一个公共且无歧义的成员，该成员指示一个 cv 无限定的非引用类型，T1 和 T2 都可以显式转换为该类型。此外，std::common_type<T1, T2>::type 和 std::common_type<T2, T1>::type 必须表示相同的类型。

违反这些规则添加 common_type 特化的程序具有未定义行为。

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

标准库已提供以下特化

(C++11)
 特化 std::common_type 特性
(类模板特化) [编辑]
(C++11)
 特化 std::common_type 特性
(类模板特化) [编辑]
(C++23)
 确定两个 pair 的共同类型
(类模板特化) [编辑]
(C++23)
 确定 tuple 和 tuple-like 类型的共同类型
(类模板特化) [编辑]
(C++23)
 确定迭代器和适配的 basic_const_iterator 类型的共同类型
(类模板特化) [编辑]

[编辑] 可能的实现

// primary template (used for zero types)
template<class...>
struct common_type {};
 
// one 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 implementation:
    // 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> {};
}
 
// two types
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 {};
 
// 3+ types
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 << "  is  Number<int>{" << x.n << "}\n";
}
 
void describe(const char* expr, const Number<double>& x)
{
    std::cout << expr << "  is  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  is  Number<int>{3}
i1 + d2  is  Number<double>{4.5}
d1 + i2  is  Number<double>{4.3}
d1 + d2  is  Number<double>{5.8}

[编辑] 缺陷报告

以下行为改变的缺陷报告被追溯应用于之前发布的 C++ 标准。

DR 应用于 已发布行为 正确行为
LWG 2141 C++11 条件运算符的结果类型未衰减 衰减了结果类型
LWG 2408 C++11 common_type 不友好的 SFINAE 使其友好 SFINAE
LWG 2460 C++11 common_type 特化几乎不可能编写 减少了
所需的特化数量

[编辑] 参见

(C++20)
 指定两种类型共享一个共同类型
(概念) [编辑]
取自“https://cppreference.cn/mwiki/index.php?title=cpp/types/common_type&oldid=180922”