Std:: swap weirdness с g++

Это странность, где я не знаю, если это со стандартом С++, с моим компилятором (g++ версия 4.6.3 на Ubuntu 12.04, которая является последней версией долгосрочной поддержки Ubuntu) или с меня, который не понимает; -)

Указанный код так же прост:

#include <algorithm>    // for std::swap
void f(void)
{
    class MyClass { };
    MyClass aa, bb;
    std::swap(aa, bb);          // doesn't compile
}

При попытке компиляции с g++ компилятор выводит следующее сообщение об ошибке:

test.cpp: In function ‘void f()’:
test.cpp:6:21: error: no matching function for call to ‘swap(f()::MyClass&, f()::MyClass&)’
test.cpp:6:21: note: candidates are:
/usr/include/c++/4.6/bits/move.h:122:5: note: template<class _Tp> void std::swap(_Tp&, _Tp&)
/usr/include/c++/4.6/bits/move.h:136:5: note: template<class _Tp, long unsigned int _Nm> void std::swap(_Tp (&)[_Nm], _Tp (&)[_Nm])

Удивительный результат заключается в том, что простое перемещение определения класса из функции делает этот код компилируемым штрафом:

#include <algorithm>    // for std::swap
class MyClass { };
void f(void)
{
    MyClass aa, bb;
    std::swap(aa, bb);          // compiles fine!
}

Итак, std:: swap() не должен работать над классами, которые являются частными для функций? Или это ошибка с g++, может быть, конкретная версия g++, которую я использую?

Еще более озадачивающим является то, что следующее работает снова, несмотря на то, что MyListClass также является приватным (но расширяет "официальный" класс, для которого может существовать определенная реализация swap()):

#include <algorithm>        // for std::swap
#include <list>             // for std::list
void g(void)
{
    class MyListClass : public std::list<int> { };
    MyListClass aa, bb;
    std::swap(aa, bb);              // compiles fine!
}

Но просто переходите от объектов к указателям, а компиляция снова завершается:

#include <algorithm>        // for std::swap
#include <list>             // for std::list
void g(void)
{
    class MyListClass : public std::list<int> { };
    MyListClass aa, bb;
    MyListClass* aap = &aa;
    MyListClass* bbp = &bb;
    std::swap(aap, bbp);    // doesn't compile!
}

Конечно, в моем реальном приложении классы более сложны; Я упростил код как можно больше, чтобы воспроизвести проблему.

Ответы

Ответ 1

Если вы работаете в режиме С++ 03, который, как я полагаю, имеет место, вы не можете использовать локально определенный тип в шаблоне. Если это так, вы можете определить свои типы на уровне пространства имен, чтобы заставить его работать, или же вы можете скомпилировать в режиме С++ 11, где он должен компилироваться. [*]

Если вы задаетесь вопросом, почему работает второй случай, стандарт не предоставляет специализации

template <typename T> void swap(T&,T&) // [1]

как std::list является самим шаблоном, и вы не можете частично специализировать функции шаблона. Он предоставляет другой базовый шаблон:

template <typename T, typename A> void swap(list<T,A>&,list<T,A>&); // [2]

Теперь, как и в предыдущем случае, компилятор не может использовать ваш локальный тип с [1], поэтому он отбрасывается. Затем он пытается [2], и обнаруживает, что он может преобразовать lvalue локального типа в ссылки на базу std::list<int>, и после этого преобразование [2] является хорошим кандидатом. Затем он вызовет

std::swap(static_cast<std::list<int&>>(aa),static_cast<std::list<int&>>(bb));

который не использует локальный тип, а уровень пространства имен std::list<int>.

С другой стороны, тот факт, что он компилируется, не означает, что он делает то, что вы хотите. В частности, если расширенный тип MyListClass добавляет любые новые переменные-члены, они будут заменены не.

Все сказанное и как примечание стороны: вы не должны наследовать от стандартных контейнеров, поскольку они никогда не были предназначены для унаследованных.

[*] Отказ от ответственности: я не знаю, поддерживается ли эта функция в этой конкретной версии компилятора, вам придется дважды проверить.