Хабрахабр

Ликбез по передаче параметров по значению в конструкторы и сеттеры (современный C++, примеры)

Судя по комментам habr.com/ru/post/460831/#comment_20416435 в соседнем посте и развернувшейся там дискуссии, на Хабре не помешает статья, как правильно передавать аргументы в конструктор или сеттер. На StackOverflow подобного материала полно, но тут что-то я не припомню.

Вот этот пример: Потому что пример в той статье полностью корректен, и автор статьи абсолютно прав.

// Хорошо.
struct person // верно , last_name{std::move(last_name)} // std::move здесь СУЩЕСТВЕНЕН! {}
private: std::string first_name; std::string last_name;
};

Такой код позволяет покрыть все (ну ладно, почти все) возможные варианты использования класса:

std::string first{"abc"}, last{"def"};
person p1{first, last}; // (1) копирование обеих строк
person p2{std::move(first), last}; // !!! копирование только второй
person p2{std::move(first), std::move(last)}; // (3) нет копирования
person p3{"x", "y"}; // нет копирования

Сравните со старым методом, когда передавали по const&: он однозначно хуже, потому что исключает вариант (3):

// Плоховато.
struct person { person(const std::string& first_name, const std::string& last_name) : first_name{first_name} , last_name{last_name} {}
private: std::string first_name; std::string last_name;
}; std::string first{"abc"}, last{"def"};
person p1{first, last}; // будет копирование, как и хотели // Но что если мы точно знаем, что first и last нам больше не
// понадобятся? мы не можем их в таком случае переместить
// и добиться 0 копирований! Поэтому const& хуже.

Альтернативный вариант с && также хуже, но в обратную сторону:

// Странновато.
struct person { person(std::string&& first_name, std::string&& last_name) : first_name{std::move(first_name)} , last_name{std::move(last_name)} {}
private: std::string first_name; std::string last_name;
}; std::string first{"abc"}, last{"def"};
person p1{std::move(first), std::move(last)}; // норм
// но вот если мы НЕ хотим перемещения, то в случае && придется хитрить:
person p2{std::string{first}, std::string{last}}; // FOOOO

Если не боитесь комбинаторного взрыва, то можете дать шанс && (но зачем? реального выигрыша в скорости не будет никакого, оптимизатор не дремлет):

// Пожалейте свою клавиатуру.
struct person { person(std::string&& first_name, std::string&& last_name) : first_name{std::move(first_name)} , last_name{std::move(last_name)} {} person(const std::string& first_name, std::string&& last_name) : first_name{first_name} , last_name{std::move(last_name)} {} person(std::string&& first_name, const std::string& last_name) : first_name{std::move(first_name)} , last_name{last_name} {} person(const std::string& first_name, const std::string& last_name) : first_name{first_name} , last_name{last_name} {}
private: std::string first_name; std::string last_name;
};

Или вот то же самое, только с шаблонами (но опять же, зачем?):

// Заумно в данном случае (из пушки по воробьям), хотя в других может быть норм.
struct person { template <typename T1, typename T2> person(T1&& first_name, T2&& last_name) : first_name{std::forward<T1>(first_name)} , last_name{std::forward<T2>(last_name)} {}
private: std::string first_name; std::string last_name;
};

Даже если у вас не std::string, а какой-то объект собственноручно написанного большущего класса, и вы хотите людей заставить перемещать его (а не копировать), то в таком случае лучше запретить конструктор копирование у этого большущего класса, нежели везде передавать его по &&. Так надежнее, да и код короче.

Напоследок пара вариантов, как делать НЕ СТОИТ:

// Кошмарно.
struct person { person(const std::string& first_name, const std::string& last_name) : first_name{first_name} , last_name{last_name} {}
private: // НЕТ и НЕТ: это мегаопасно, никогда не сохраняйте константные // ссылки в свойствах объекта const std::string& first_name; const std::string& last_name;
}; person p{"x", "y"}; // ха-ха-ха, приехали

И так тоже не надо:

// Плоховато.
struct person { person(std::string& first_name, std::string& last_name) : first_name{first_name} , last_name{last_name} {}
private: // так можно иногда, но лучше все же воспользоваться shared_ptr: // будет медленнее, но безопасно std::string& first_name; std::string& last_name;
};

Почему так происходит, каков фундаментальный принцип? Он прост: объект, как правило, должен ВЛАДЕТЬ своими свойствами.

Кстати, shared_ptr'ы в таком случае тоже надо передавать по значению, а не по константной ссылке — тут разницы с самым первым примером в начале статьи никакой: Если объект не хочет чем-то владеть, то он может владеть shared_ptr'ом на это «что-то».

// Лучше (если нет выхода).
struct person { person(std::shared_ptr<portfolio> pf) : pf{std::move(pf)} // std::move здесь важен для производительности {}
private: std::shared_ptr<portfolio> pf;
}; auto psh = std::make_shared<portfolio>("xxx", "yyy", "zzz");
...
person p1{psh};
person p2{std::move(psh)}; // (X) так эффективнее, если psh больше не нужен

Обратите внимание: std::move для shared_ptr совершенно легален, он исключает накладные расходы на блокировку счетчика ссылок shared_ptr в памяти (сотни циклов CPU) и на его инкремент. Он никак не влияет на время жизни объекта и остальные ссылки на него. Но (X) можно делать, конечно, только в случае, если ссылка psh в коде ниже нам больше не нужна.

Смотрите по обстоятельствам. Мораль: не используйте const& повально.

S.
Используйте {} вместо () при передаче параметров конструктора. P. Модно, современно, молодежно.

Теги
Показать больше

Похожие статьи

Добавить комментарий

Ваш e-mail не будет опубликован. Обязательные поля помечены *

Кнопка «Наверх»
Закрыть