Реализация своп в копии и идиома своп

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

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

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 ...
}

Жить на Колиру

Для приведенного выше контекста, где нужно только применить какое-то внутреннее ограничение, лучше использовать значение по умолчанию и просто применять только один раз ограничение в конструкторе прямой инициализации. Тем не менее, если вам нужно реализовать эти функции, посмотрите на ответ @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;
}