Реализация подкачки в идиоме копирования и подкачки

Я так понимаю, мы пост С++ 11?

В этом случае реализация std::swap по умолчанию будет оптимальной, при условии, что мы правильно реализуем оператор перемещения-присваивания и конструктор перемещения (в идеале - nothrow).

http://en.cppreference.com/w/cpp/algorithm/swap

#include <iostream>

class Bar {
public:
    Bar(unsigned int bottles=0) : bottles(bottles) { enforce(); } // (1)
    Bar(Bar const & b) : bottles(b.bottles) {
        // b has already been enforced. is enforce necessary here?
        enforce();
    } // (1)
    Bar(Bar&& b) noexcept
    : bottles(std::move(b.bottles))
    {
        // no need to enforce() because b will have already been enforced;
    }

    Bar& operator=(Bar&& b) noexcept
    {
        auto tmp = std::move(b);
        swap(tmp);
        return *this;
    }

    Bar & operator=(Bar const & b)
    {
        Bar tmp(b); // but apart from resource management it allows (1)
        swap(tmp);
        return *this;
    }

    void swap(Bar & that) noexcept {
        using std::swap;
        swap(bottles, that.bottles);
    }

    friend std::ostream & operator<<(std::ostream & out, Bar const & b) {
        out << b.bottles << " bottles";
        return out;
    }

private:
    unsigned int bottles;
    void enforce() {  } // (1)
};

/* not needed anymore
void swap(Bar & man, Bar & woman) { // (2)
    man.swap(woman);
}
*/
int main () {
    Bar man (5);
    Bar woman;

    std::cout << "Before -> m: " << man << " / w: " << woman << std::endl;
    using std::swap;
    swap(man, woman);
    std::cout << "After  -> m: " << man << " / w: " << woman << std::endl;

    return 0;
}

ожидаемый результат:

Before -> m: 5 bottles / w: 0 bottles
After  -> m: 0 bottles / w: 5 bottles

РЕДАКТИРОВАТЬ:

В интересах всех, кто беспокоится о производительности (например, @JosephThompson), позвольте мне развеять ваши опасения. После переноса вызова std::swap в виртуальную функцию (чтобы заставить clang вообще создавать какой-либо код) и компиляции с помощью apple clang с -O2 это:

void doit(Bar& l, Bar& r) override {
    std::swap(l, r);
}

стало так:

__ZN8swapper24doitER3BarS1_:            ## @_ZN8swapper24doitER3BarS1_
    .cfi_startproc
## BB#0:
    pushq   %rbp
Ltmp85:
    .cfi_def_cfa_offset 16
Ltmp86:
    .cfi_offset %rbp, -16
    movq    %rsp, %rbp
Ltmp87:
    .cfi_def_cfa_register %rbp
    movl    (%rsi), %eax
    movl    (%rdx), %ecx
    movl    %ecx, (%rsi)
    movl    %eax, (%rdx)
    popq    %rbp
    retq
    .cfi_endproc 

Видеть? оптимальный. Стандартная библиотека С++ рулит!

Примечание. Это способ использования копирования и подкачки, существовавший до C++11. Для решения C++11 см. этот ответ

Чтобы заставить это работать, вам нужно исправить пару вещей. Сначала вам нужно предварительно объявить функцию swap free, чтобы operator= знал об этом. Для этого вам также необходимо предварительно объявить Bar, чтобы swap был тип с именем bar

class Bar;

void swap(Bar & man, Bar & woman);

// rest of code

Затем нам нужно указать компилятору, где искать swap. Мы делаем это с помощью оператора разрешения области видимости. Это укажет компилятору искать в области видимости класса функцию swap.

Bar & operator=(Bar const & b) {
  // bottles = b.bottles;
  // enforce();
  // Copy and swap idiom (maybe overkill in this example)
  Bar tmp(b); // but apart from resource management it allows (1)
            // to enforce a constraint on the internal state
  ::swap(*this, tmp); // Can't see the swap non-member function (2)
//^^ scope operator 
  return *this;
}

Собираем все вместе и получаем этот живой пример.

Действительно, хотя копия operator = должна выглядеть так

Bar & operator=(Bar b) // makes copy
{
    ::swap(*this, b) // swap the copy
    return *this; // return the new value
}

Вы знаете, что Bar имеет функцию-член swap, поэтому просто вызовите ее напрямую.

Bar& operator=(Bar const& b) {
    Bar tmp(b);
    tmp.swap(*this);
    return *this;
}

Нечлен swap существует только для того, чтобы клиенты Bar могли воспользоваться преимуществами его оптимизированной реализации swap, не зная, существует ли она, используя идиому using std::swap для включения поиск в зависимости от аргумента:

using std::swap;
swap(a, b);

Вам также необходимо включить std::swap в этой функции.

using std::swap;
swap(*this, tmp); // Can't see the swap non-member function (2)

Цитируя ответ, на который вы ссылались:

Если теперь используется своп, как показано в 1), ваша функция будет найдена.

Способ его использования:

{
  using std::swap; // enable 'std::swap' to be found
                   // if no other 'swap' is found through ADL
  // some code ...
  swap(lhs, rhs); // unqualified call, uses ADL and finds a fitting 'swap'
                  // or falls back on 'std::swap'
  // more code ...
}

Прямая трансляция на Coliru

Для приведенного выше контекста, где нужно только применить какое-то внутреннее ограничение, лучше использовать значение по умолчанию и просто применять ограничение только один раз в конструкторе прямой инициализации. Тем не менее, если вам нужно реализовать эти функции, посмотрите ответ @RichardHodges! См. также комментарий @HowardHinnant (особенно часть слайдов, когда компилятор делает магию неявно объявляет специальные члены...).

Вот что у меня получилось (без явного копирования и подкачки):

#include <iostream>

class Bar {
public:
  Bar(unsigned int bottles=0) : bottles(bottles) { enforce(); } // The only point of enforcement

  friend std::ostream & operator<<(std::ostream & out, Bar const & b) {
    out << b.bottles << " bottles";
    return out;
  }

private:
  unsigned int bottles;
  void enforce() { bottles /= 2; bottles *=2; }
};

int main () {
  Bar man (5);
  Bar woman;

  std::cout << "Before -> m: " << man << " / w: " << woman << std::endl;
  using std::swap; // Argument dependent lookup
  swap(man, woman);
  std::cout << "After  -> m: " << man << " / w: " << woman << std::endl;

  return 0;
}

Теперь, что произойдет, если Bar наследуется от Foo (которому не нужен enforce). Это первоначальный вариант использования, который заставил меня подумать, что мне нужно развернуть свои собственные специальные функции и извлечь выгоду из копирующей части копии и заменить идиому на enforce ограничение. Получается, что даже в этом случае мне не нужно:

#include <iostream>

class Foo {
public:
  Foo(unsigned int bottles=11) : bottles(bottles) {} // This is odd on purpose

  virtual void display(std::ostream & out) const {
    out << bottles << " bottles";
  }

protected:
  unsigned int bottles;
};

std::ostream & operator<<(std::ostream & out, Foo const & f) {
  f.display(out);
  return out;
}

class Bar : public Foo {
public:
  Bar(unsigned int bottles=0) : Foo(bottles) { enforce(); }
  Bar(Foo const & f) : Foo(f) { enforce(); }

  void display(std::ostream & out) const override {
    out << bottles << " manageable bottles";
  }

private:
  void enforce() { bottles /= 2; bottles *=2; }
};

int main () {
  Bar man (5); // Again odd on purpose
  Bar woman;

  std::cout << "Before -> m: " << man << " / w: " << woman << std::endl;
  using std::swap; // Argument dependent lookup
  swap(man, woman);
  std::cout << "After  -> m: " << man << " / w: " << woman << std::endl;

  Foo fool(7); // Again odd
  Bar like(fool);
  std::cout << fool << " -> (copy) " << like << std::endl;
  Bar crazy;
  crazy = fool;
  std::cout << fool << " ->   (=)  " << crazy << std::endl;

  return 0;
}