`std :: common_type`是关联的吗?

时间:2015-12-22 10:52:04

标签: c++ templates c++11 types metaprogramming

模板类std::common_type计算可变参数类型列表的公共类型。 It is defined using the return type of the ternary operator x:y?z recursively.根据该定义,对我而言,计算std::common_type<X,Y>是否为关联是不明显的,i。即是否

using namespace std;
static_assert( is_same<common_type< X, common_type<Y,Z>::type    >::type,
                       common_type<    common_type<X,Y>::type, Z >::type>::value, "" );
对于X表达式有效的所有类型YZis_same<...>

永远不会抛出编译时错误。

请注意,我不是在问

static_assert( is_same<common_type<X,Y>::type,
                       common_type<Y,X>::type>::value, "" );

永远都会开火。显然不会。以上是一个完全不同的问题。

另请注意,std::common_type的规范在C ++ 14中略有变化,并且可能会在C ++ 17中再次发生变化。因此,对于不同版本的标准,答案可能会有所不同。

3 个答案:

答案 0 :(得分:11)

这在MinGW-w64(gcc 4.9.1)上失败。 VS2013和(感谢Baum mit Augen)在gcc5.2或clang 3.7上使用libc ++也失败了。

#include <type_traits>

using namespace std;

struct Z;
struct X{operator Z();};
struct Y{operator X();};
struct Z{operator Y();};

static_assert( is_same<common_type<X,Y>::type,
                       common_type<Y,X>::type>::value, "" ); // PASS

static_assert( is_same<common_type<X,Z>::type,
                       common_type<Z,X>::type>::value, "" ); // PASS

static_assert( is_same<common_type<Y,Z>::type,
                       common_type<Z,Y>::type>::value, "" ); // PASS

static_assert( is_same<common_type< X, common_type<Y,Z>::type    >::type,
                       common_type<    common_type<X,Y>::type, Z >::type>::value, "" ); // FAIL...

答案 1 :(得分:5)

#include <type_traits>

struct T2;
struct T1 {
    T1(){}
    T1(int){}
    operator T2();
};
struct T2 {
    operator int() { return 0; }
};
struct T3 {
    operator int() { return 0; }
};
T1::operator T2() { return T2(); }

using namespace std;
using X = T1;
using Y = T2;
using Z = T3;
int main()
{

    true?T2():T3(); // int
    static_assert(std::is_same<std::common_type_t<T2,
                                                  T3>,
                               int>::value,
                  "Not int");

    true?T1():(true?T2():T3()); // T1
    static_assert(std::is_same<std::common_type_t<T1,
                                                  std::common_type_t<T2,
                                                                     T3>>,
                               T1>::value,
                  "Not T1");

    // -----------------------------------------

    true?T1():T2(); // T2
    static_assert(std::is_same<std::common_type_t<T1,
                                                  T2>,
                               T2>::value,
                  "Not T2");

    true?(true?T1():T2()):T3(); // int
    static_assert(std::is_same<std::common_type_t<std::common_type_t<T1,
                                                                     T2>,
                                                  T3>,
                               int>::value,
                  "Not int");

    // -----------------------------------------

    static_assert( is_same<common_type_t< X, common_type_t<Y,Z>    >,
                           common_type_t<    common_type_t<X,Y>, Z > >::value,
                    "Don't match");
}

哎哟!这里的心理体操伤了我的脑袋,但我想出了一个无法编译的案例,在{{3}上使用gcc 4.9.2和“C ++ 14”(gcc 5.1)打印“不匹配” }。现在,这是否符合要求是另一回事......

现在声明属于班级类型,std::common_type_t<X, Y>应为XY,但我强制std::common_type_t<T2, T3>转换为int。< / p>

请尝试其他编译器,让我知道会发生什么!

答案 2 :(得分:2)

它没有联想!这是一个失败的程序:

#include <type_traits>

struct Z;
struct X { X(Z); }; // enables conversion from Z to X
struct Y { Y(X); }; // enables conversion from X to Y
struct Z { Z(Y); }; // enables conversion from Y to Z

using namespace std;    
static_assert( is_same<common_type< X, common_type<Y,Z>::type    >::type,
                       common_type<    common_type<X,Y>::type, Z >::type>::value, 
               "std::common_type is not associative." );

这个想法很简单:下图显示了common_type计算的内容:

    X,Y -> Y
    Y,Z -> Z
    X,Z -> X

第一行是合乎逻辑的,因为X可以转换为Y,但反之亦然。其他两行也一样。将XY合并并与Z重新合并后,我们会获得Z。另一方面,将YZ以及结合X与结果相结合会得到X。因此结果不同。

这种可能性的根本原因是可兑换性不是传递性的,即:即如果X可转换为YY可转换为Z,则X无法转换为Z。如果可转换性是可传递的,那么转换将双向工作,因此common_type无法明确计算并导致编译时错误。

这种推理与标准版本无关。它适用于C ++ 11,C ++ 14和即将推出的C ++ 17。