使用 Visual Studio 2010 SP1:

#include <vector>

//namespace XXX {
  struct Test
  {
    bool operator==(const Test& r) const  { return true; }
  };
//}
//typedef XXX::Test Test;

template <typename T> inline bool operator!=(const T& l,const T& r) 
{ return !(l==r); }

int main()
{
  std::vector<Test> vt;
  std::vector<Test> vt2 = std::move(vt);
  return 0;
}

如果我按原样编译上面的代码，它会失败并出现以下错误:

1>C:\apps\MVS10\VC\include\vector(609): error C2593: 'operator !=' is ambiguous
1>          C:\apps\MVS10\VC\include\xmemory(268): could be 'bool std::operator !=<_Ty,_Ty>(const std::allocator<_Ty> &,const std::allocator<_Ty> &) throw()'
1>          with
1>          [
1>              _Ty=Test
1>          ]
1>          test.cpp(11): or       'bool operator !=<std::allocator<_Ty>>(const T &,const T &)' [found using argument-dependent lookup]
1>          with
1>          [
1>              _Ty=Test,
1>              T=std::allocator<Test>
1>          ]
1>          while trying to match the argument list '(std::allocator<_Ty>, std::allocator<_Ty>)'
1>          with
1>          [
1>              _Ty=Test
1>          ]
1>          C:\apps\MVS10\VC\include\vector(606) : while compiling class template member function 'void std::vector<_Ty>::_Assign_rv(std::vector<_Ty> &&)'
1>          with
1>          [
1>              _Ty=Test
1>          ]

... 其中 vector(609) 解析为这一行:

        else if (get_allocator() != _Right.get_allocator())

OTOH，如果我取消注释 namespace XXX 相关的行，它会毫无怨言地编译。

我不得不认为这是一个编译器错误，但我正在寻找一些独立的验证。

编辑: 作为解释，我在第一次使用 VS2010 重新编译一些旧代码时遇到了这种情况。 global operator 是过去几年的产物(现已移除)。我只是无法理解为什么有些代码会失败而其他代码却不会。上面的代码是我对失败案例的提炼(显然，旧代码不会包含对 std::move() 的调用)。

更新:我用 MS 记录了一个错误，他们回复说这已在“编译器的下一个版本中”修复 - 我认为这意味着 Visual C++ 11。参见:http://connect.microsoft.com/VisualStudio/feedback/details/731692/regression-involving-global-operator-and-std-vector

最佳答案

这是一个错误。

您已决定提供 operator!=对于所有类型，这显然会导致与已经定义了此类运算符的类型发生冲突。

在解析对 operator!= 的调用期间进行参数相关查找两个之间std::allocator<Test> s 在你的库实现中 ^[1] 允许 Test 的命名空间在试图找到 std 时被搜索(以及 operator!= )使用^[2]。

所以:

• 在您损坏的情况下，该 namespace 是全局 namespace ，它还包含一个 operator!=那匹配。现在，这应该无关紧要，因为命名空间 std 中的函数是更好的匹配^[3]； VS 错误是产生了歧义。

• 但是当Test而是在命名空间 XXX 中(尽管 typedef )，由于上述规则搜索的 namespace 是 namespace XXX ，其中不包含 operator!= 的冲突定义.

无论如何，最好不要像那样为所有类型定义运算符。

[1] ^{您的线路的部分实现 std::vector<Test> vt2 = std::move(vt);在你的编译器/库中 impl 正在调用 bool operator!=<std::allocator<Test>>(const std::allocator<Test>&, const std::allocator<Test>&) .}

[2] ^{引用如下:}

^{[C++11: 3.4.2/1]: When the postfix-expression in a function call (5.2.2) is an unqualified-id, other namespaces not considered during the usual unqualified lookup (3.4.1) may be searched, and in those namespaces, namespace-scope friend function declarations (11.3) not otherwise visible may be found. These modifications to the search depend on the types of the arguments (and for template template arguments, the namespace of the template argument).}

^{[C++11: 3.4.2/2]: For each argument type T in the function call, there is a set of zero or more associated namespaces and a set of zero or more associated classes to be considered. The sets of namespaces and classes is determined entirely by the types of the function arguments (and the namespace of any template template argument). Typedef names and using-declarations used to specify the types do not contribute to this set. The sets of namespaces and classes are determined in the following way:}

• ^[..]
• ^{If T is a class type (including unions), its associated classes are: the class itself; the class of which it is a member, if any; and its direct and indirect base classes. Its associated namespaces are the namespaces of which its associated classes are members. Furthermore, if T is a class template specialization, its associated namespaces and classes also include: the namespaces and classes associated with the types of the template arguments provided for template type parameters (excluding template template parameters); the namespaces of which any template template arguments are members; and the classes of which any member templates used as template template arguments are members. [ Note: Non-type template arguments do not contribute to the set of associated namespaces. —end note ]}
• ^[..]

[3] ^{引用如下:}

^{[C++11: 13.3.3/1]: Given these definitions, a viable function F1 is defined to be a better function than another viable function F2 if for all arguments i, ICSi(F1) is not a worse conversion sequence than ICSi(F2), and then:}

• ^[..]
• ^{F1 and F2 are function template specializations, and the function template for F1 is more specialized than the template for F2 according to the partial ordering rules described in 14.5.6.2.}

^{[C++11: 14.5.6.2/2]: Partial ordering selects which of two function templates is more specialized than the other by transforming each template in turn (see next paragraph) and performing template argument deduction using the function type. The deduction process determines whether one of the templates is more specialized than the other. If so, the more specialized template is the one chosen by the partial ordering process.}

^{我的解释是这个过程决定了std中的函数比全局命名空间中的那个“更专业”，所以实际上不应该有歧义。}

_{感谢@BoPersson 和@DavidRodríguez 为这个精彩的回答做出的宝贵贡献。}

关于c++ - 这是一个 VC++2010 编译器错误吗？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/9728693/