C++模板swap函数出现重载歧义问题求助

在学习C++模板时，编写了一个基于引用的简单swap模板函数用于交换整数，但用GCC 13和Clang编译时都出现了重载歧义错误。

自定义代码如下：

#include <iostream>

template<typename T>
void swap(T &a, T &b) {
  T temp;

  temp = a;
  a = b;
  b = temp;
}

int main() {
    using namespace std;

    int a,b;

    a = 7, b = 10;

    cout << "a is " << a << " while b is " << b << endl;
    swap(a,b);
    cout << "a is " << a << " while b is " << b << endl;
    
    return 0;
}

GCC 13编译错误： #

<source>: In function 'int main()':
<source>:21:9: error: call of overloaded 'swap(int&, int&)' is ambiguous
   21 |     swap(a,b);
      |     ~~~~^~~~~
In file included from /opt/compiler-explorer/gcc-13.1.0/include/c++/13.1.0/bits/exception_ptr.h:41,
                 from /opt/compiler-explorer/gcc-13.1.0/include/c++/13.1.0/exception:164,
                 from /opt/compiler-explorer/gcc-13.1.0/include/c++/13.1.0/ios:41,
                 from /opt/compiler-explorer/gcc-13.1.0/include/c++/13.1.0/ostream:40,
                 from /opt/compiler-explorer/gcc-13.1.0/include/c++/13.1.0/iostream:41,
                 from <source>:2:
/opt/compiler-explorer/gcc-13.1.0/include/c++/13.1.0/bits/move.h:196:5: note: candidate: 'std::_Require<std::__not_<std::__is_tuple_like<_Tp> >, std::is_move_constructible<_Tp>, std::is_move_assignable<_Tp> > std::swap(_Tp&, _Tp&) [with _Tp = int; _Require<__not_<__is_tuple_like<_Tp> >, is_move_constructible<_Tp>, is_move_assignable<_Tp> > = void]'
  196 |     swap(_Tp& __a, _Tp& __b)
      |     ^~~~
<source>:5:6: note: candidate: 'void swap(T&, T&) [with T = int]'
    5 | void swap(T &a, T &b) {
      |      ^~~~

Clang编译错误： #

<source>:21:5: error: call to 'swap' is ambiguous
    swap(a,b);
    ^~~~
/opt/compiler-explorer/gcc-12.2.0/lib/gcc/x86_64-linux-gnu/12.2.0/../../../../include/c++/12.2.0/bits/move.h:196:5: note: candidate function [with _Tp = int]
    swap(_Tp& __a, _Tp& __b)
    ^
<source>:5:6: note: candidate function [with T = int]
void swap(T &a, T &b) {
     ^
1 error generated.

问题原因 #

是的，C++标准库（STL）中已经提供了std::swap模板函数，定义在<utility>头文件中（<iostream>会间接包含这个头文件）。

代码里使用了using namespace std;，这会把std命名空间下的所有名字（包括std::swap）导入到当前全局命名空间。此时调用swap(a,b)时，编译器会找到两个完全匹配的函数：

1. 自定义的全局swap模板（实例化为swap(int&, int&)）
2. std::swap模板（实例化为std::swap(int&, int&)）

两个函数的匹配度完全相同，编译器无法判断应该调用哪一个，因此抛出重载歧义错误。

解决办法 #

有几种常见的解决方式：

• 避免使用using namespace std;
  改用显式的std::前缀调用标准库组件，避免全局命名空间被污染：

  int main() {
      int a,b;
      a = 7, b = 10;
  
      std::cout << "a is " << a << " while b is " << b << std::endl;
      swap(a,b); // 仅调用自定义swap
      std::cout << "a is " << a << " while b is " << b << std::endl;
      
      return 0;
  }
  

• 显式指定调用自定义swap
  如果坚持使用using namespace std;，可以通过全局命名空间前缀::明确调用自己定义的swap：

  ::swap(a,b); // 强制调用全局命名空间下的swap
  

• 将自定义swap放入专属命名空间
  把自己的模板放到单独的命名空间中，避免和标准库名字冲突：

  namespace my_utils {
      template<typename T>
      void swap(T &a, T &b) {
          T temp = a;
          a = b;
          b = temp;
      }
  }
  
  int main() {
      using namespace std;
      int a =7, b=10;
      cout << "a is " << a << " while b is " << b << endl;
      my_utils::swap(a,b); // 调用自定义命名空间下的swap
      cout << "a is " << a << " while b is " << b << endl;
      return 0;
  }
  

• 直接使用标准库的std::swap
  标准库的std::swap已经经过优化，对于基本类型（比如int）的交换效率和自定义版本完全一致，甚至复杂类型可能有更高效的实现。无特殊需求时直接使用即可：

  std::swap(a,b);
  

内容的提问来源于stack exchange，提问作者Skegg