最終更新日時(UTC):
が更新

履歴 編集

class template
<type_traits>

std::common_type(C++11)

namespace std {
  template <class... Types>
  struct common_type {
    using type = ;
  };

  template <class... T>
  using common_type_t = typename common_type<T...>::type; // C++14
}

概要

変換可能な共通の型を取得する。

要件

Types...の全ての型は完全型であるか、const/volatile修飾された(あるいはされていない)voidか、要素数不明の配列型でなければならない。

効果

common_typeは、Types...に含まれる全ての型が暗黙変換可能な型を、メンバ型typeとして定義する。

より詳細には、次のように決定される。ただし、C++11ではdecayを適用するプロセスが、C++14では下記N == 2の時のプロセスが、それぞれ行われない。

N = sizeof...(Types)として

  • N == 0 : メンバ型typeは定義されない。

  • N == 1 : Types...内の唯一の型をTとすると、type = common_type_t<T, T>;のようにtypeを定義。

  • N == 2 : Types...の1、2番目の型をT1, T2D1 = decay_t<T1>, D2 = decay_t<T2>として
    • T1,T2に対するdecayの適用は、少なくとも片方が恒等写像とならない(is_same_v<T1, D1> && is_same_v<T2, D2> == falseとなる)場合
      type = common_type_t<D1, D2>;のようにtypeを定義。
    • そうではなく、ユーザ定義の特殊化もない場合、type = decay_t<decltype(false ? declval<D1>() : declval<D2>())>;のようにtypeを定義。
    • 上記の様な型が定義できない場合、メンバ型typeは定義されない。
  • N >= 3 : Types...の1、2番目の型をT1, T2、残りのパラメータパックをP...とすると、type = common_type_t<common_type_t<T1, T2>, P...>;のようにtypeを定義。
    • 先頭2つの型の共通型を求めて、その型と3番目の型の共通型を求めて、その型と4番目の...というように再帰的にcommon_typeを適用していく。

2つの型T1, T2に対するdecayの適用がともに恒等写像となるのは以下の場合である。

  • T1, T2はともに配列型ではなく
  • T1, T2はともに関数型でもなく
  • T1, T2はともに参照型でもなく
  • T1, T2はともにCV修飾もされていない

特殊化

common_typeは以下の条件を満たす場合に、2引数のもの(common_type<T1, T2>)に限ってユーザー定義の特殊化が許可されている。

  • T1, T2の少なくとも片方はユーザー定義型に依存している
    • 「ユーザー定義型に依存している」とは例えば、ユーザー定義型に対するvector等の特殊化のこと
  • T1, T2に対するdecayの適用はともに恒等写像となる(上記参照)

そして、そのような特殊化は必ずしもメンバ型typeを持たなくても構わない。
もしtypeを定義する場合はpublicにただ一つだけ定義し、その型はT1, T2から明示的に変換可能であり、かつCV修飾されておらず参照型でもない型である必要がある。
そして、その特殊化はT1,T2の引数順を入れ替えても同じ結果を返す(対称性を持つ)必要がある。
これらの規則に違反した特殊化を定義したとしてもコンパイルエラーにはならず、未定義動作となる。

このように定義されたユーザー定義の特殊化は、common_type_t<T1, T2>のように使用された時T1, T2がともにCV修飾もなく参照でもない場合は直接利用される。
T1, T2のどちらかがCV修飾されているか参照である場合は、プライマリのcommon_typeによってdecayされた上で利用される。

なお、common_type以外の<type_traits>内テンプレートに対するユーザー定義の特殊化は許可されていない。

#include <iostream>
#include <type_traits>

// 2つの値どちらが小さいかを返すアルゴリズム
// 型Tと型Uの共通の型を戻り値型にする
template <class T, class U>
typename std::common_type<T, U>::type
  generic_min(T t, U u)
{
  return t < u ? t : u;
}

int main()
{
  auto x = generic_min(3L, 2);

  static_assert(
    std::is_same<decltype(x), long>::value == true,
    "type of x is long");

  std::cout << x << std::endl;
}

出力

2

定義(C++11)

template <class ...T>
struct common_type;

template <class T>
struct common_type<T> {
  using type = T;
};

template <class T, class U>
struct common_type<T, U> {
  using type = decltype(true ? declval<T>() : declval<U>());
};

template <class T, class U, class... V>
struct common_type<T, U, V...> {
  using type = typename common_type<typename common_type<T, U>::type, V...>::type;
};

定義(C++14)

template <class ...T>
struct common_type;

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

template <class T>
struct common_type<T> {
  using type = decay_t<T>;
};

template <class T, class U>
struct common_type<T, U> {
  using type = decay_t<decltype(true ? declval<T>() : declval<U>())>;
};

template <class T, class U, class... V>
struct common_type<T, U, V...> {
  using type = common_type_t<common_type_t<T, U>, V...>;
};

バージョン

言語

  • C++11

処理系

  • Clang: 3.0
  • GCC, C++11 mode: 4.4.7
  • Visual C++: 2010, 2012, 2013, 2015
    • 2012までは、可変引数テンプレートに対応していないため、不完全な実装である。
    • common_type_tは、2013から。

参照