Неразрешен външен използващ шаблонен клас с копиране и размяна

Това е често срещан проблем, когато се сприятелявате с функции, които не са членове, с шаблони. Декларацията friend вътре в TemplateClass не се сприятелява с вашия swap шаблон, а по-скоро с нешаблонирана безплатна функция swap, която взема TemplateClass<T> за всеки T шаблонът, който е създаден (т.е. специализацията TemplateClass<int> ще се сприятелява с безплатна функция void swap( TemplateClass<int>&,TemplateClass<int>& );, която не е шаблонирана).

Най-доброто решение е да предоставите swap дефиницията, вградена в дефиницията на шаблона на класа, тъй като това ще накара компилатора да генерира нешаблонирана swap функция за точния тип, когато е необходимо. Като друг положителен страничен ефект, тази функция swap ще бъде намерена само по време на търсене в зависимост от аргумента, така че няма да вземе участие в разрешаването на претоварване за всичко, което не включва вашия шаблон.

Други алтернативи са сприятеляване на цялата функция на шаблона swap или сприятеляване на конкретната специализация на функцията swap, когато се прилага към същия T, с който шаблонът е създаден. Първата от опциите е проста в кода, но дава достъп до всички специализации на шаблона swap и това може да има лоши странични ефекти. Сприятеляването с конкретната специализация swap решава този проблем, но е малко по-сложно за изпълнение (трябва да препратите декларацията на шаблона на класа, след това шаблона swap, след това да дефинирате шаблона на класа и накрая да дефинирате шаблона swap).

Повече за това в този друг отговор, където различните опции и синтаксисът е обяснен с повече подробности.

Що се отнася до конкретното съобщение за грешка на unresolved external, това се дължи на начина, по който работи търсенето на идентификатор. Когато сте използвали swap(*this,other); във функция член, търсенето започва вътре в класа и се опитва да намери подходящ swap. Първо търси в контекста на класа и намира декларацията на безплатната функция friend, така че търсенето не продължава да излиза навън и добавя зависимост към тази конкретна безплатна функция. Той добавя зависимостта и изчаква линкерът да намери подходящия символ. Тъй като компилаторът никога не е разглеждал шаблонния swap на ниво пространство от имена, той никога не го е инстанцирал, но дори и да е инстанцирал този шаблон, зависимостта вътре в членската функция operator= е от свободна функция, а не от тази специализация.

Трябва или да поставите декларацията на шаблона на клас в заглавния файл, или ако знаете предварително всички типове, с които този шаблон на клас ще бъде инстанциран, осигурете изрично инстанциране в заглавния файл:

template< class T >
class TemplateClass
{
    // ...
    TemplateClass< T >& operator= ( TemplateClass< T > other );
    friend void swap( TemplateClass< T >& first, TemplateClass< T >& second );
    // ...
};

template class TemplateClass<FirstType>;
template class TemplateClass<SecondType>;
// ...

// and the same for swap function
template void swap<FirstType>( TemplateClass<FirstType>& first, TemplateClass<FirstType>& second );
template void swap<SecondType>( TemplateClass<SecondType>& first, TemplateClass<SecondType>& second );

Досадно е, но понякога е най-добрият вариант.

Относно защо вашият суап не се свързва: вие декларирате приятели с функция суап без шаблон, която не съществува. Опитайте това:

template< class T >
class TemplateClass
{
    // ...
    TemplateClass< T >& operator= ( TemplateClass< T > other );
    template < class U > friend void swap( TemplateClass< U >& first, TemplateClass< U >& second );
    // ...
};

Необходими са допълнителни усилия, ако искате да сте пуристи и да бъдете приятели само с „вашия“ swap (swap със същите параметри на шаблона).