Про копирование и перемещение объектов в C++

28 июня 2017

Мне лично в языке C++ всегда казалась довольно сложной для понимания тема всех эти copy assignment’ов, move constructor’ов, perfect forwarding’а и вот этого всего. Поскольку без этих знаний в современном C++ далеко не уедешь, решил попробовать во всем разобраться. Не могу сказать, что теперь владею материалом в совершенстве, но на небольшую заметку-введение вроде наскреблось. Авось кому будет интересно.

Базовый код с запретом копирования и присваивания

Если вы пока точно не знаете, как будет использоваться класс, лучше всего просто запретить копирование и присваивание. По умолчанию они разрешены и просто копируют все атрибуты класса. Часто это не то, чего вы хотите. Например, тупо копировать какие-то указатели, файловые дескрипторы или мьютексы, являющиеся атрибутами класса, явно плохая идея. Простейший код, в котором копирование и присваивание класса явно запрещены:

#include <iostream>

class Coord2D {
public:
    Coord2D() {
        _x = 0;
        _y = 0;
        std::cout << "Coord2D(x = " << _x << ", y = " << _y <<
                     ") created" << std::endl;
    }

    Coord2D(int x, int y) {
        _x = x;
        _y = y;
        std::cout << "Coord2D(x = " << _x << ", y = " << _y <<
                     ") created" << std::endl;
    }

    ~Coord2D() {
        std::cout << "Coord2D(x = " << _x << ", y = " << _y <<
                     ") destroyed" << std::endl;
    }

    int getX() const { return _x; }
    int getY() const { return _y; }
    Coord2D& setX(int x) { _x = x; return *this; }
    Coord2D& setY(int y) { _y = y; return *this; }

    Coord2D(Coord2D const &) = delete;
    void operator=(Coord2D const &) = delete;
private:
    int _x, _y;
};

int main() {
    Coord2D c1;
    Coord2D c2(1, 2);

    std::cout << "Hi!" << std::endl;
}

Вывод программы:

Coord2D(x = 0, y = 0) created
Coord2D(x = 1, y = 2) created
Hi!
Coord2D(x = 1, y = 2) destroyed
Coord2D(x = 0, y = 0) destroyed

Пока что никаких неожиданностей. Стоит отметить, что вместо:

    Coord2D(Coord2D const &) = delete;
    void operator=(Coord2D const &) = delete;

… можно написать:

    Coord2D(Coord2D const &) = default;
    void operator=(Coord2D const &) = default;

… тем самым явно указав на то, что вас устраивают реализации по умолчанию.

Copy constructor

Объявим copy contructor:

/* ... */

    Coord2D(Coord2D const & obj) {
        _x = obj._x;
        _y = obj._y;
        std::cout << "Coord2D(x = " << _x << ", y = " << _y <<
                     ") copied" << std::endl;
    }

/* ... */

int main() {
    Coord2D c1(1, 2);
    Coord2D c2(c1);
    Coord2D c3 = c1;
    std::cout << "Hi!" << std::endl;
}

Заметьте, что в нем мы имеем доступ к private полям второго экземпляра класса (obj), несмотря на то, что это другой экземпляр. Вывод программы:

Coord2D(x = 1, y = 2) created
Coord2D(x = 1, y = 2) copied
Coord2D(x = 1, y = 2) copied
Hi!
Coord2D(x = 1, y = 2) destroyed
Coord2D(x = 1, y = 2) destroyed
Coord2D(x = 1, y = 2) destroyed

Оба синтаксиса эквивалентны, в обоих случаях был вызван copy constructor. Конструктор для каждого объекта был вызван один раз. Можно было и не писать этот код, так как реализация copy constructor по умолчанию и так просто копирует атрибуты класса.

Copy assignment

Объявим copy assignment оператор:

/* ... */

    void operator=(Coord2D const & obj) {
        _x = obj._x;
        _y = obj._y;
        std::cout << "Coord2D(x = " << _x << ", y = " << _y <<
                     ") copy-assigned" << std::endl;
    }

/* ... */

int main() {
    Coord2D c1(1, 2);
    Coord2D c2(c1);
    Coord2D c3 = c1;

    c2 = c3;

    std::cout << "Hi!" << std::endl;
}

Вывод:

Coord2D(x = 1, y = 2) created
Coord2D(x = 1, y = 2) copied
Coord2D(x = 1, y = 2) copied
Coord2D(x = 1, y = 2) copy-assigned
Hi!
Coord2D(x = 1, y = 2) destroyed
Coord2D(x = 1, y = 2) destroyed
Coord2D(x = 1, y = 2) destroyed

Заметьте, что деструктор при присвоении не вызывается. Это означает, что в реализации copy assignment следует освобождать старые ресурсы перед присвоением новых значений.

Move constructor

Перепишем код следующим образом:

/* ... */

Coord2D id(Coord2D x) {
    std::cout << "id called" << std::endl;
    return x;
}

int main() {
    Coord2D c1 = id(Coord2D(1,2));
    c1.setX(-1);
    std::cout << "Hi!" << std::endl;
}

Вывод:

Coord2D(x = 1, y = 2) created
id called
Coord2D(x = 1, y = 2) copied
Coord2D(x = 1, y = 2) destroyed
Hi!
Coord2D(x = -1, y = 2) destroyed

Как видите, мы создаем копию из временного объекта, после чего он сразу уничтожается. Для нас это не проблема, так как объект маленький. Но если бы он содержал в себе большие объемы данных, мы бы создали их полную копию, а затем одну из копий освободили бы. Для решения этой проблемы придумали move constructor:

/* ... */
    Coord2D(Coord2D&& obj) {
        _x = obj._x;
        _y = obj._y;
        std::cout << "Coord2D(x = " << _x << ", y = " << _y <<
                     ") moved" << std::endl;
    }
/* ... */

Вывод:

Coord2D(x = 1, y = 2) created
id called
Coord2D(x = 1, y = 2) moved
Coord2D(x = 1, y = 2) destroyed
Hi!
Coord2D(x = -1, y = 2) destroyed

Move constructor вызывается вместо copy constructor в случае, когда объект, из которого создается копия, вот-вот будет уничтожен. В таком конструкторе обычно данные из временного объекта переносятся в новый объект, а полям временного объекта присваиваются nullptr или что-то такое. Важно понимать, что при выходе из move constructor оба объекта должны оставаться валидными и для обоих должен корректно отрабатывать деструктор. Ссылка T&& называется rvalue reference и означает ссылку на объект, который вот-вот будет уничтожен.

Move assignment

Аналогично move constructor, только для присваивания. Например, код:

int main() {
    Coord2D c1(1,2);
    c1 = Coord2D(4,5);

    std::cout << "Hi!" << std::endl;
}

… выведет:

Coord2D(x = 1, y = 2) created
Coord2D(x = 4, y = 5) created
Coord2D(x = 4, y = 5) copy-assigned
Coord2D(x = 4, y = 5) destroyed
Hi!
Coord2D(x = 4, y = 5) destroyed

Объявим move assignment оператор:

/* ... */
    void operator=(Coord2D&& obj) {
        _x = obj._x;
        _y = obj._y;
        std::cout << "Coord2D(x = " << _x << ", y = " << _y <<
                     ") move-assigned" << std::endl;
    }
/* ... */

Вывод:

Coord2D(x = 1, y = 2) created
Coord2D(x = 4, y = 5) created
Coord2D(x = 4, y = 5) move-assigned
Coord2D(x = 4, y = 5) destroyed
Hi!
Coord2D(x = 4, y = 5) destroyed

Move assignment оператор позволяет применить те же оптимизации, что и move constructor. В move constructor поля объекта, переданного в качестве аргумента, обычно как-то зануляются. В move assignment лучше сделать swap полей в двух объектах. Это позволит избавиться от дублирования кода между оператором move assignment и деструктором.

std::move

Move constructor бывает трудно стригерить. Например, код:

int main() {
    Coord2D c1(Coord2D(1,2).setX(5));
    std::cout << "Hi!" << std::endl;
}

… выведет:

Coord2D(x = 1, y = 2) created
Coord2D(x = 5, y = 2) copied
Coord2D(x = 5, y = 2) destroyed
Hi!
Coord2D(x = 5, y = 2) destroyed

Так происходит, потому что метод setX возвращает lvalue reference, а у move constructor на входе совершенно другой тип, rvalue reference. Чтобы явно показать, что временный объект мы больше использовать не будем, предусмотрен std:move. Если переписать код так:

int main() {
    Coord2D c1(std::move(Coord2D(1,2).setX(5)));
    std::cout << "Hi!" << std::endl;
}

… программа выведет:

Coord2D(x = 1, y = 2) created
Coord2D(x = 5, y = 2) moved
Coord2D(x = 5, y = 2) destroyed
Hi!
Coord2D(x = 5, y = 2) destroyed

В сущности, std::move просто кастует lvalue reference (T&) в rvalue reference (T&&), больше ничего. При чтении кода std::move как бы говорит нам, что мы отдаем владение объектом в этом месте и далее не собираемся его использовать.

std::forward

Шаблон std::forward предназначен исключительно для написания шаблонных методов, способных принимать на вход как lvalue, так и rvalue, в зависимости от того, что передал пользователь, и передавать соответствующий тип далее без изменений. Техника получила название perfect forwarding.

Рассмотрим пример. Определим оператор сложения двух координат:

/* ... */

    template<class T>
    friend Coord2D operator+(T&& a, const Coord2D& b) {
        std::cout << "Creating `Coord2D t`..." << std::endl;
        Coord2D t(std::forward<T>(a));
        std::cout << "`Coord2D t` created!" << std::endl;

        return t.setX(t.getX() + b.getX()).setY(t.getY() + b.getY());
    }

/* ... */

int main() {
    Coord2D c1(1,1), c2(1,2), c3(1,3);
    Coord2D c4 = c1 + c2 + c3;

    std::cout << "Hi!" << std::endl;
}

Вывод:

Coord2D(x = 1, y = 1) created
Coord2D(x = 1, y = 2) created
Coord2D(x = 1, y = 3) created
Creating `Coord2D t`...
Coord2D(x = 1, y = 1) copied
`Coord2D t` created!
Coord2D(x = 2, y = 3) copied
Coord2D(x = 2, y = 3) destroyed
Creating `Coord2D t`...
Coord2D(x = 2, y = 3) moved
`Coord2D t` created!
[...]

Смотрите, что происходит. При первом вызове оператора сложения переменная t инициализируется при помощи copy constructor, так как c1 не является временным объектом. Однако при втором вызове первым аргументом передается временный объект c1 + c2, и из него переменная t инициализируется уже при помощи move constructor. То есть, фактически std::forward позволил написать процедуру один раз, вместо того, чтобы писать две версии — одну, принимающую первым аргументом lvalue reference, и вторую, работающую с rvalue reference.

Заключение

Заметьте, что думать про всякие move semantics и perfect forwarding нужно только при работе с объектами, держащими в себе много данных, и только если вы часто копируете или присваиваете такие объекты. Это исключительно оптимизация, и без нее все будет совершенно корректно работать (более того, ничего этого не существовало до появления C++11). Пока профайлер не говорит вам, что вы во что-то такое не уперлись, возможно, не стоит заморачиваться. Помните также, что компилятор зачастую может избавляться от лишнего копирования объектов, см return value optimization (RVO) и copy elision.

С другой стороны, теорию понимать стоит независимо от того, упирается ваш код в копирование и перемещение объектов, или нет. Как минимум, move semantics и иже с ним может использоваться в чужом коде. В частности, он используется в STL, см например метод emplace_back класса std::vector, или метод emplace класса std::map.

Дополнительные материалы:

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

Метки: .

Подпишись через RSS, E-Mail, Google+, Facebook, Vk или Twitter!

Понравился пост? Поделись с другими: