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

Question

模板类std::common_type 计算一个通用类型到一个可变类型列表。 It is defined using the return type of the ternary operator x:y?z recursively. 从该定义来看，计算 std::common_type<X,Y> 是否具有关联性对我来说并不明显，即。 e.是否

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, "" );

对于is_same<...> 表达式有效的所有类型X、Y 和Z，永远不会抛出编译时错误。

请注意，我不是在问是否

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

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

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

Answer 1

这在 MinGW-w64(gcc 4.9.1) 上失败。在 VS2013 和 gcc5.2 上（感谢 Baum mit Augen）或带有 libc++ 的 clang 3.7 上也失败。

#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...

Answer 2

#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");
}

哎哟！这里的心理体操让我头疼，但我想出了一个无法编译的案例，在ideone 上打印“不匹配”、gcc 4.9.2 和“C++14”（gcc 5.1）。现在是否符合是另一回事......

现在声明是针对类类型的，std::common_type_t<X, Y> 应该是 X 或 Y，但我已强制 std::common_type_t<T2, T3> 转换为 int。

请尝试使用其他编译器并告诉我会发生什么！

Answer 3

它不是关联的！这是一个失败的程序：

#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，反之则不行。其他两条线也一样。一旦X 和Y 与Z 组合并重新组合，我们得到Z。另一方面，结合Y 和Z 以及结合X 与结果得到X。因此结果是不同的。

这可能的根本原因是可兑换性不是传递性的，即。 e.如果X 可转换为Y 和Y 可转换为Z，则并不意味着X 可转换为Z。如果可转换性是可传递的，则转换将双向起作用，因此无法明确计算 common_type 并导致编译时错误。

这个推理独立于标准版本。它适用于 C++11、C++14 和即将推出的 C++17。