std::common_type

ヘッダ `<type_traits>` で定義
template< class... T > struct common_type;		(C++11以降)

T... のすべての型の間にある共通の型を決定します。これは、すべての T... が明示的に変換可能であるような型です。このような型が存在する場合（以下の規則に従って決定されます）、メンバー type はその型を指します。存在しない場合は、メンバー type はありません。

sizeof...(T) がゼロの場合、メンバー type は存在しません。
もし sizeof...(T) が 1（つまり、T... には単一の型 T0 のみを含む）である場合、メンバー type は、存在すれば std::common_type<T0, T0>::type と同じ型を指します。存在しない場合は、メンバー type はありません。
もし sizeof...(T) が 2（つまり、T... がちょうど 2 つの型 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 はその型を指します。条件演算子を参照してください。

それ以外の場合で、CR1 と CR2 がそれぞれ const std::remove_reference_t<T1>& および const std::remove_reference_t<T2>& である場合、std::decay<decltype(false ? std::declval<CR1>() : std::declval<CR2>())>::type が有効な型である場合、メンバー type はその型を指します。

(C++20以降)

それ以外の場合、メンバー type はありません。

もし sizeof...(T) が 2 より大きい場合（つまり、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 という名前のメンバーがある場合、それは公開され、曖昧さのないメンバーであり、T1 と T2 の両方が明示的に変換可能な cv 修飾されていない参照型でない型を指す必要があります。さらに、std::common_type<T1, T2>::type と std::common_type<T2, T1>::type は同じ型を指す必要があります。

これらの規則に違反して common_type 特殊化を追加するプログラムは、未定義の動作を引き起こします。

<type_traits> の他のテンプレート（std::basic_common_reference を除く）に特殊化を追加するプログラムの動作は未定義であることに注意してください。

標準ライブラリによってすでに提供されている特殊化は以下のとおりです。

std::common_type<std::chrono::duration> (C++11)	std::common_type トレイトを特殊化します。 (クラステンプレートの特殊化) [edit]
std::common_type<std::chrono::time_point> (C++11)	std::common_type トレイトを特殊化します。 (クラステンプレートの特殊化) [edit]
std::common_type<std::pair> (C++23)	2つの`pair`の共通型を決定する (クラステンプレート特殊化) [編集]
std::common_type<tuple-like> (C++23)	`tuple` と `tuple-like` 型の共通型を決定する (クラステンプレート特殊化) [編集]
std::common_type<std::basic_const_iterator> (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	条件演算子の結果型が decay されていなかった。	結果型を decay させた。
LWG 2408	C++11	`common_type` は SFINAE フレンドリーではなかった。	SFINAEフレンドリーにされた
LWG 2460	C++11	`common_type` の特殊化の作成がほとんど不可能だった。	特殊化の数を減らした。必要な特殊化。

[編集] 関連項目

common_with

(C++20)

2つの型が共通の型を共有することを規定する
(コンセプト) [編集]

コンパイラサポート
フリースタンディングとホスト
言語
標準ライブラリ
標準ライブラリヘッダー
名前付き要件
機能テストマクロ (C++20)
言語サポートライブラリ
コンセプトライブラリ (C++20)
診断ライブラリ
メモリ管理ライブラリ
メタプログラミングライブラリ (C++11)
汎用ユーティリティライブラリ
コンテナライブラリ
イテレータライブラリ
Rangesライブラリ (C++20)
アルゴリズムライブラリ
文字列ライブラリ
テキスト処理ライブラリ
数値ライブラリ
日付と時刻ライブラリ
入出力ライブラリ
ファイルシステムライブラリ (C++17)
並行サポートライブラリ (C++11)
実行制御ライブラリ (C++26)
Technical specifications (技術仕様)
シンボルインデックス
外部ライブラリ

cppreference.com

名前空間

変種

表示

操作

std::common_type

目次

[編集] ネストされた型

[編集] ヘルパー型

[編集] 特殊化

[編集] 実装例

[編集] 注

[編集] 例

[編集] 不具合報告

[編集] 関連項目

ナビゲーション

ツールボックス

template< class... T > using common_type_t = typename common_type<T...>::type;		(C++14以降)

名前	定義
`type`	すべての `T` に対する共通の型