在 Clang 上重载运算符歧义，但在 GCC 上没有，哪一个是正确的？

Question

#include <iostream>


template <typename T>
struct Wrapper {
    operator T const &() const & {
        std::cout << "Wrapper::operator T const &() const &\n";
        return _obj;
    }

    operator T&() & {
        std::cout << "Wrapper::operator T&() &\n";
        return _obj;
    }

    operator T&&() && {
        std::cout << "Wrapper::operator T&&() &&\n";
        return std::move(_obj);
    }

private:
    T _obj;
};

struct Test {
    Test& operator=(Test const &test) {
        std::cout << "Test& Test::operator=(Test const &)\n";
        return *this;
    }

    Test& operator=(Test &&test) {
        std::cout << "Test& Test::operator=(Test &&)\n";
        return *this;
    }
};

int main() {
    Test test;
    Wrapper<Test> wrapperTest;

    test = wrapperTest;               // OK for all
    test = std::move(wrapperTest);    // OK for GCC and ICC, not for Clang and VC++

    return 0;
}

VC++：

(34): 错误 C2593: 'operator =' 不明确

(26): 注意：可能是'Test &Test::operator =(Test &&)'

(25): note: or 'Test &Test::operator =(const Test &)'

(69): 注意：在尝试匹配参数列表时 '(Test, Wrapper)'

========== 构建：0 成功，1 失败，0 最新，0 跳过 ==========

叮当声：

:34:7: 错误：重载运算符“=”的使用不明确（操作数类型为“Test”和“typename std::remove_reference &>::type”（又名“Wrapper”））

test = std::move(wrapperTest); // 适用于 GCC 和 ICC，不适用于 Clang 和 Microsoft Visual C++

~~~ ^ ~~~~~~~~~~~~~~~~~~~~~~~~~

:25:8: 注意：候选函数

Test& operator=(Test const &test) { std::cout

^

:26:8: 注意：候选函数

Test& operator=(Test &&test) { std::cout

^

生成 1 个错误。

Answer 1

我认为 gcc 和 icc 是正确的。

test = std::move(wrapperTest);

将Wrapper<Test>&& 分配给Test，由于此调用没有候选匹配项，它将考虑最多需要1 次转换的操作。

来自Value categories：

当用作函数参数并且函数的两个重载可用时，一个采用右值引用参数，另一个采用左值引用到 const 参数，右值绑定到右值引用重载（因此，如果复制和移动构造函数可用，右值参数调用移动构造函数，复制和移动赋值运算符也是如此）。

还有Non-static member functions：

非静态成员函数可以用左值引用限定符（函数名后面的标记 &）或右值引用限定符（函数名后面的标记 &&）来声明。在重载决议期间，类 X 的非静态 cv 限定成员函数被视为一个函数，如果它没有 ref-qualifiers 或如果它具有 lvalue ref-qualifier，则该函数采用对 cv-qualified X 的左值引用类型的隐式参数.否则（如果它有 rvalue ref-qualifier），它被视为一个函数，该函数采用 cv 限定 X 的右值引用类型的隐式参数。

现在，我们有这些候选人：

• Test& operator=(Test &&test)operator T&&() &&
• Test& operator=(Test const &test)operator T const &() const &

根据这些段落，编译器应该选择Test& operator=(Test &&test) by operator T&&() &&