Делаем своп быстрее, проще в использовании и безопасным для исключений

template <typename T>
void swap(T& a, T& b)
{
    T c(a);
    a = b;
    b = c;
}

#include <utility>

template <typename T>
void swap(T& a, T& b)
{
    T c(std::move(a));
    a = std::move(b);
    b = std::move(c);
}

#include <cstring>

template <typename T>
void swap(T& a, T& b)
{
    unsigned char c[sizeof(T)];

    memcpy( c, &a, sizeof(T));
    memcpy(&a, &b, sizeof(T));
    memcpy(&b,  c, sizeof(T));
}

template <typename T>
void swap(T& a, T& b)
{
    if (false)    // dead code, never executed
    {
        T c(a);   // copy-constructible?
        a = b;    // assignable?
    }

    unsigned char c[sizeof(T)];

    std::memcpy( c, &a, sizeof(T));
    std::memcpy(&a, &b, sizeof(T));
    std::memcpy(&b,  c, sizeof(T));
}

Ответ 2 · рейтинг 20 · Sergei Tachenov

Это сломает экземпляры классов, которые имеют указатели на свои собственные члены. Например:

class SomeClassWithBuffer {
  private:
    enum {
      BUFSIZE = 4096,
    };
    char buffer[BUFSIZE];
    char *currentPos; // meant to point to the current position in the buffer
  public:
    SomeClassWithBuffer();
    SomeClassWithBuffer(const SomeClassWithBuffer &that);
};

SomeClassWithBuffer::SomeClassWithBuffer():
  currentPos(buffer)
{
}

SomeClassWithBuffer::SomeClassWithBuffer(const SomeClassWithBuffer &that)
{
  memcpy(buffer, that.buffer, BUFSIZE);
  currentPos = buffer + (that.currentPos - that.buffer);
}

Теперь, если вы просто выполните memcpy(), куда укажет currentPos? Очевидно, на старое место. Это приведет к очень забавным ошибкам, когда каждый экземпляр фактически использует буфер другого.

Ответ 3 · рейтинг 7 · Fred Nurk

Некоторые типы можно поменять местами, но нельзя скопировать. Уникальные интеллектуальные указатели, вероятно, лучший пример. Проверка на копируемость и присваиваемость неверна.

Если T не является типом POD, использование memcpy для копирования/перемещения является неопределенным поведением.

---

Обычная идиома состоит в том, чтобы предоставить метод void Foo::swap(Foo&other) и специализацию std::swap‹Foo>. Обратите внимание, что это не работает с шаблонами классов,...

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

struct NonTemplate {};
void swap(NonTemplate&, NonTemplate&);

template<class T>
struct Template {
  friend void swap(Template &a, Template &b) {
    using std::swap;
#define S(N) swap(a.N, b.N);
    S(each)
    S(data)
    S(member)
#undef S
  }
};

Ключом является использование объявления для std::swap в качестве запасного варианта. Дружба для обмена шаблона удобна для упрощения определения; своп для NonTemplate тоже может подойти, но это деталь реализации.

Ответ 4 · рейтинг 6 · Puppy

Я считаю это незначительной проблемой, потому что такие объекты, вероятно, не должны были обеспечивать операции копирования в первую очередь.

То есть, попросту говоря, куча неправильных вещей. Классы, которые уведомляют наблюдателей, и классы, которые не следует копировать, совершенно не связаны между собой. Как насчет shared_ptr? Это, очевидно, должно быть копируемым, но оно также, очевидно, уведомляет наблюдателя о подсчете ссылок. Это правда, что в этом случае счетчик ссылок остается таким же после подкачки, но это определенно не верно для всех типов, и это особенно неверно, если используется многопоточность, это неверно для случай обычной копии вместо замены и т. д. Это особенно неправильно для классов, которые можно перемещать или менять местами, но не копировать.

потому что в целом операции перемещения разрешены для броска

Наверняка нет. Практически невозможно гарантировать надежную защиту от исключений практически при любых обстоятельствах, связанных с ходами, когда ход может привести к срабатыванию. В определении C++0x стандартной библиотеки из памяти явно указано, что любой тип, используемый в любом стандартном контейнере, не должен вызываться при перемещении.

Это настолько эффективно, насколько это возможно

Это тоже неправильно. Вы предполагаете, что перемещение любого объекта является чисто его переменными-членами, но это могут быть не все из них. У меня может быть кеш, основанный на реализации, и я могу решить, что в моем классе я не должен перемещать этот кеш. В качестве детали реализации я полностью вправе не перемещать какие-либо переменные-члены, которые я считаю ненужными. Однако вы хотите переместить их все.

Это правда, что ваш пример кода должен быть действителен для многих классов. Тем не менее, это совершенно определенно недопустимо для многих классов, которые полностью и полностью законны, и, что более важно, он будет компилироваться в эту операцию в любом случае, если операция может быть сведена к этому. Это ломает совершенно хорошие классы абсолютно бесполезно.

Ответ 5 · рейтинг 1 · smerlin

ваша swap версия вызовет хаос, если кто-то будет использовать ее с полиморфными типами.

учитывать:

Base *b_ptr = new Base();    // Base and Derived contain definitions
Base *d_ptr = new Derived(); // of a virtual function called vfunc()
yourmemcpyswap( *b_ptr, *d_ptr );
b_ptr->vfunc(); //now calls Derived::vfunc, while it should call Base::vfunc
d_ptr->vfunc(); //now calls Base::vfunc while it should call Derived::vfunc
//...

это неправильно, потому что теперь b содержит виртуальную таблицу типа Derived, поэтому Derived::vfunc вызывается для объекта, который не имеет типа Derived.

Обычный std::swap меняет местами только элементы данных Base, поэтому с std::swap все в порядке.