std::common_type

来自cppreference.com
< cpp‎ | types
 
 
工具库
类型支持(基本类型、 RTTI 、类型特性)
动态内存管理
错误处理
程序工具
变参数函数
日期和时间
函数对象
(C++11)
关系运算符
optionalanyvariant (C++17)
pair 与 tuple
(C++11)
(C++17)
swap 、 forward 与 move
(C++14)
(C++11)
(C++11)
初等字符串转换
(C++17)
(C++17)
类型运算
(C++11)
(C++17)
 
类型支持
基本类型
基础类型
定宽整数类型 (C++11)
数值极限
C 数值极限接口
运行时类型信息
类型特性
类型类别
(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++11)(C++17 中弃用)
(C++11)
类型特性常量
元函数
(C++17)
端序
(C++20)
受支持操作
关系与属性查询
(C++11)
(C++11)
(C++11)
(C++11)
类型修改
(C++11)
(C++11)
(C++11)
类型变换
(C++11)
(C++11)
(C++17)
common_type
(C++11)
(C++11)(C++17 中弃用)
(C++17)
 
定义于头文件 <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... 含恰好二个成员 T1T2 ),则
  • 若应用 std::decay 到至少 T1T2 中至少一个类型后产生相异类型,则成员 type 指名与 std::common_type<std::decay<T1>::type, std::decay<T2>::type>::type 相同的类型,若它存在;若不存在,则无成员 type
  • 否则,除非存在 std::common_type<T1, T2> 的用户定义特化,否则成员 type 都指代类型 std::decay<decltype(false ? std::declval<T1>() : std::declval<T2>())>::type ,若该表达式为良态;若表达式为病态,则无成员 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 起)

[编辑] 特化

用户可为类型 T1T2 特化 common_type ,只要

  • T1T2 至少一个依赖于用户定义类型,且
  • std::decay 对于 T1T2 都是同等变换。

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

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

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

标准库已提供下列特化:

特化 std::common_type 特性
(类模板特化) [编辑]
特化 std::common_type 特性
(类模板特化) [编辑]

[编辑] 可能的实现

// 初等模板(用于零个类型)
template <class ...T> struct common_type { }; 
 
//////// 一个类型
template <class T>
struct common_type<T> {
    using type = std::decay_t<T>;
};
 
//////// two types
 
// 二个类型的默认实现
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() 的(可以为混合模式的)算术表达式的类型。

[编辑] 缺陷报告

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

DR 应用于 出版时的行为 正确行为
LWG 2141 C++11 common_type<int, int>::typeint&& 退化了结果类型
LWG 2408 C++11 common_type 非 SFINAE 友好 令之为 SFINAE 友好
LWG 2460 C++11 common_type 特化的书写近乎不可能 减少了需要的特化数量

[编辑] 示例

演示用户定义类上的混合模式算术

#include <iostream>
#include <type_traits>
 
template <class T>
struct Number { T n; };
 
template <class T, class U>
Number<typename std::common_type<T, U>::type> operator+(const Number<T>& lhs,
                                                        const Number<U>& rhs) 
{
    return {lhs.n + rhs.n};
}
 
int main()
{
    Number<int> i1 = {1}, i2 = {2};
    Number<double> d1 = {2.3}, d2 = {3.5};
    std::cout << "i1i2: " << (i1 + i2).n << "\ni1d2: " << (i1 + d2).n << '\n'
              << "d1i2: " << (d1 + i2).n << "\nd1d2: " << (d1 + d2).n << '\n';
}

输出:

i1i2: 3
i1d2: 4.5
d1i2: 4.3
d1d2: 5.8