Предоставянето на swap() за C++ шаблонен клас нарушава std::swap()?

Подходът, възприет от 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);
   }
}

Включете следния ред в Matrix:

template<typename U> friend void swap(Matrix<U> &first, Matrix<U> &second);

и дефинирайте swap извън класа. Причината да получавате грешката function template has already been defined е, че всяко инстанциране на Matrix<unsigned short> и Matrix<char> ще съдържа една и съща дефиниция на вашата функция за размяна, тъй като сте дефинирали функцията приятел вътре в шаблона Matrix.

Следното се изгражда чисто за мен с VC++ 2010 SP1:

Matrix.h:

#pragma once

#include <algorithm>
#include <vector>

namespace my_space
{
    template<typename T>
    class Matrix
    {
    public:
        Matrix(unsigned const w, unsigned const h)
          : width_(w), height_(h), data_(w * h)
        { }

    private:
        unsigned width_;
        unsigned height_;
        std::vector<T> data_;

        friend void swap(Matrix& lhs, Matrix& rhs)
        {
            using std::swap;
            swap(lhs.width_,  rhs.width_);
            swap(lhs.height_, rhs.height_);
            swap(lhs.data_,   rhs.data_);
        }
    };
}

.cpp:

#include "Matrix.h"

int main()
{
    using namespace my_space;
    using std::swap;

    int a(0), b(1);
    swap(a, b);

    Matrix<int> c(2, 3), d(4, 5);
    swap(c, d);

    Matrix<short> e(6, 7), f(8, 9);
    swap(e, f);
}

Тъй като не сте публикували SSCCE (подсказка, подсказка ), много е трудно да видите къде точно грешите, но можете да използвате това като отправна точка, за да стесните проблема си.

Ако кодът наистина е като това, което сте публикували, това е проблем с компилатора. Кодът се компилира добре в clang++, както трябва.

Приятелските декларации са странни с това, че декларират функция, която има обхват на пространство от имена, но декларацията е налична само през ADL и дори тогава, само ако поне един от аргументите е от типа на класа, който има приятелската декларация. Освен ако няма декларация на ниво пространство от имена, функцията не е налична в обхвата на пространството от имена.

Тест 1 (функцията не е налична на ниво пространство от имена без изрична декларация):

namespace A {
   struct B {
      friend void f();  // [1]
   };
   // void f();         // [2]
}
void A::f() {}          // [3]

В [1] добавяме декларация за приятел, която декларира void A::f() като приятел на A::B. Без допълнителната декларация в [2] на ниво пространство от имена, дефиницията в [3] няма да успее да се компилира, тъй като е извън пространството от имена A, тази дефиниция не е също и самодекларация.

Изводът тук е, че тъй като функцията не е достъпна за търсене на ниво пространство от имена, а само чрез ADL на Matrix<T> (за някакъв конкретен инстанциращ тип T), компилаторът не може да намери това като съвпадение на размяна на две int стойности.

В отговора си Джеси Гуд заявява, че всяка инстанция на Matrix и Matrix ще съдържа една и съща дефиниция на вашата функция за размяна, тъй като сте дефинирали функцията приятел вътре в шаблона Matrix, което е пълен абсурд.

Приятелска функция, която е дефинирана вътре в класа, ще декларира и дефинира функция на ниво пространство от имена и отново, декларацията ще бъде налична само вътре в класа и достъпна чрез ADL. Когато това се направи в шаблон, той ще дефинира нешаблонирана безплатна функция на ниво пространство от имена за всяко екземпляр на шаблона, който използва функцията. Тоест, ще генерира различни дефиниции. Обърнете внимание, че вътре в обхвата на шаблона на класа името на шаблона идентифицира специализацията, която се инстанцира, т.е. вътре в Matrix<T> идентификаторът Matrix не наименува шаблона, а едно инстанциране на шаблона.

Тест 2

namespace X {
   template <typename T>
   struct A {
      friend void function( A ) {}
   };
   template <typename T>
   void funcTion( A<T> ) {}
}
int main() {
   using namespace X;
   A<int> ai;    function(ai); funcTion(ai);
   A<double> ad; function(ad); funcTion(ad);
}

$ make test.cpp
$ nm test | grep func | c++filt
0000000100000e90 T void X::funcTion<double>(A<double>)
0000000100000e80 T void X::funcTion<int>(A<int>)
0000000100000e70 T X::function(A<double>)
0000000100000e60 T X::function(A<int>)

Резултатът от nm е списъкът със символи, а c++filt ще преведе повредените имена в еквивалента в синтаксиса на C++. Резултатът от програмата ясно показва, че X::funcTion е шаблон, който е създаден за два типа, докато X::function са две претоварени функции без шаблон. Отново: две функции без шаблон.

Твърдението, че ще генерира същата функция, няма много смисъл, помислете, че има извикване на функция, да речем std::cout << lhs, кодът трябва да избере правилното претоварване на operator<< за текущото инстанциране на функцията. Няма нито един operator<<, който може да приеме да речем int и unsigned long или std::vector<double> (Нищо не ви пречи да създадете шаблона с всеки тип.

Отговорът от ildjarn предлага алтернатива, но не дава обяснение на поведението. Алтернативата работи, защото using-директива е напълно различна от using-declaration. По-специално, първото (using namespace X;) променя търсенето, така че идентификаторите в пространството от имена X да са достъпни на ниво пространство от имена в едно от обграждащите пространства от имена на текущата част от кода (ако изградите дърво от пространства от имена, декларациите биха били налични там, където клонът, съдържащ X, отговаря на клона, съдържащ кода, където се използва using-директивата).

От друга страна, using-declaration (using std::swap;) осигурява using-declaration на функцията std::swap в контекста, където присъства using-declaration . Ето защо трябва да използвате using-declarations, а не using-directives, за да приложите вашите swap функции:

Тест 3

namespace Y { struct Z {}; void swap( Z&,Z& ); }
namespace X {
   struct A { int a; Y::Z b; };
   void swap( A& lhs, A& rhs ) {
      //using namespace std;       // [1]
      using std::swap;             // [2]
      swap( lhs.a, rhs.a );        // [3]
      swap( lhs.b, rhs.b );        // [4]
   }
}

Ако бяхме използвали using-директива [1], символите от пространството от имена ::std щяха да бъдат достъпни за търсения, извършени във функцията ::X::swap(X::A&,X::A&), сякаш бяха декларирани в :: (което е общият предшественик на ::std и ::X). Сега суапът в [3] няма да намери никаква swap функция чрез ADL, така че ще започне да търси swap функции в обхващащото пространство от имена. Първото обхващащо пространство от имена е X и то съдържа функция swap, така че търсенето ще спре и ще се активира разрешаването на претоварване, но X::swap не е валидно претоварване за swap(int&,int&), така че няма да успее да се компилира.

Чрез използване на using-declaration ние привеждаме std::swap декларация в обхвата на X::swap (вътре във функцията!). Отново ADL няма да бъде приложен в [3] и търсенето ще започне. В текущия обхват (вътре във функцията) той ще намери декларацията на std::swap и ще инстанцира шаблона. В [4] ADL се включва и ще търси функция swap, дефинирана вътре във функцията ::Y::Z и/или в ::Y, и ще добави това към набора от претоварвания, намерени в текущия обхват ( отново, ::std::swap). В този момент ::Z::swap е по-добро съвпадение от std::swap (предвид перфектно съвпадение, функция без шаблон е по-добро съвпадение от шаблонна) и получавате очакваното поведение.