c++ - 为 C++ 模板类提供 swap() 中断 std::swap()？

Question

我正在尝试实现 copy-and-swap idiom在我的自定义 Matrix 类中，我按照链接问题中建议的方式执行 swap() 时遇到了一些麻烦:

(我使用的编译器是MS VS2010 IDE的编译器，方言是很好的老式C++03。)

// matrix.h

namespace my_space 
{

template<typename T> class Matrix
{
public:
    /* ... */

    friend void swap(Matrix<T> &first, Matrix<T> &second)
    {
        using std::swap;
        swap(first.width_, second.width_);
        swap(first.height_, second.height_);
        swap(first.data_, second.data_);
    }
};

} // namespace

现在我无法在代码中访问位于此命名空间中的函数的常规 std::swap():

// some_code.cpp:
#include "matrix.h"
#include <algorithm>

using namespace my_space;
using namespace std;

// SomeClass is part of my_space!
void SomeClass::some_function()
{
    int a = 3, b = 7;
    swap(a,b);  // I wan't std::swap!
}

不幸的是，出于某种原因，Matrix 的 my_space::swap() 似乎是对 std::swap() 的所有其他调用的别名，我没有想法为什么因为参数不适合并且 ADL 应该支持 std::swap:

1>f:\src\some_code.cpp(653): error C3767: 'swap': candidate function(s) not accessible
1>          could be the friend function at 'f:\src\matrix.h(63)' : 'swap'  [may be found via argument-dependent lookup]

(错误在我尝试使用 std::swap 的每一行重复 10 次)

my_space::swap() 是否总是否决 my_space 中的 std::swap()，即使参数不合适？这并不是说 std::swap() 不可见，而且在创建 my_space::swap() 之前它工作正常。

Answer 1

STL 容器采用的方法是使用成员函数，然后重载静态函数。例如:

template<class T, class Alloc=std::allocator<T> >
class vector
{
   T *data;
   size_t n;
   size_t max_n;
public:
   void swap(vector<T, Alloc> &other)
   {
      swap(this->data, other.data);
      swap(this->n, other.n);
      swap(this->max_n, other.max_n);
   }
};

template<class T, class A>
void swap(vector<T, A> &lhs, vector<T, A> &rhs)
{
   lhs.swap(rhs);
}

在建议的 Matrix 类中，只需采用相同的方法...

namespace my_space
{
template<typename T>
class Matrix
{
   unsigned width_;
   unsigned height_;
   std::vector<T> data_;
public:
   void swap(Matrix<T> &other)
   {
      std::swap(this->width_, other.width_);
      std::swap(this->height_, other.height_);
      std::swap(this->data_, other.data_);  // calls this->data_.swap(other.data_);
   }
};
}

namespace std
{
   template<typename T>
   void swap(my_space::Matrix<T> &lhs, my_space::Matrix<T> &rhs)
   {
      lhs.swap(rhs);
   }
}