Эффективный и современный С++. 42 рекомендации по использованию С++11 и С++14 - [124]

Даже когда вы имеете дело с функцией, выполняющей безусловное копирование копируемого типа с дешевым перемещением, бывают моменты, когда передача по значению может оказаться неприемлемой. Это связано с тем, что функция может копировать параметр двумя способами: с помощью конструирования (т.e. с помощью копирующего конструктора или перемещающего конструктора) и с помощью присваивания (т.e. с помощью оператора копирующего или перемещающего присваивания). Функция addName использует конструирование: ее параметр newName передается функции vector::push_back, и внутри этой функции newName конструируется копированием в новом элементе в конце вектора std::vector. Для функций, которые используют конструирование для копирования своего параметра, анализ, который мы видели ранее, завершен: использование передачи по значению приводит к дополнительному перемещению как для lvalue-аргументов, так и для rvalue-аргументов.

Когда параметр копируется с использованием присваивания, ситуация становится более сложной. Предположим, например, что у нас есть класс, представляющий пароли. Поскольку пароль может изменяться, мы предоставляем функцию установки changeTo. Используя стратегию передачи по значению, реализовать Password можно следующим образом:

class Password {
public:
 explicit Password(std::string pwd) // Передача по значению;
 : text(std::move(pwd)) {}          // конструирование text

 void changeTo(std::string newPwd)  // Передача по значению;
 { text = std::move(newPwd); }      // присваивание text
 …
private:
 std::string text;                  // Текст пароля
};

Хранение паролей в виде обычного текста приведет специалистов по безопасности в неистовство, но мы их проигнорируем и рассмотрим следующий код:

std::string initPwd("Supercalifragilisticexpialidocious");
Password p(initPwd);

Здесь нет никаких сюрпризов: p.text конструируется с использованием заданного пароля, а применение передачи по значению в конструкторе приводит к стоимости перемещающего конструирования std::string, которое может оказаться излишним при применении перегрузки или прямой передачи. Все в порядке.

Пользователь этой программы может быть не столь оптимистичным насчет пароля, так как слово “Supercalifragilisticexpialidocious” можно найти в словаре. А потому он предпринимает действия, которые ведут к выполнению следующего кода:

std::string newPassword = "Beware the Jabberwock";
p.changeTo(newPassword);

Лучше новый пароль старого или нет — вопрос сложный, но это проблемы пользователя. Нашей же проблемой является то, что необходимость функции changeTo использовать присваивание (а не конструирование) для копирования параметра newPwd, вероятно, приведет к росту стоимости стратегии передачи параметра по значению.

Аргумент, переданный функции changeTo, представляет собой lvalue (newPassword), так что, когда конструируется параметр newPwd, вызывается копирующий конструктор std::string. Этот конструктор выделяет память для хранения нового пароля. Затем newPwd присваивается с перемещением переменной text, что приводит к освобождению памяти, которая ранее принадлежала этой переменной text. Таким образом, в changeTo выполняются два действия по управлению динамической памятью: одно выделяет память для хранения нового пароля, а второе освобождает память, в которой хранился старый пароль.

Но в данном случае старый пароль (“Supercalifragilisticexpialidocious”) длиннее нового (“Beware the Jabberwock”), так что нет необходимости в выделении и освобождении памяти вовсе. Если бы использовался подход с перегрузкой, вероятно, никакие выделения и освобождения не выполнялись бы:

class Password {
public:
 …
 void changeTo(const std::string& newPwd) // Перегрузка для
 {                                        // lvalue
  text = newPwd;   // При text.capacity() >= newPwd.size()
                   // можно использовать память text
 }
 …
private:
 std::string text; // Как выше
};

В этом сценарии стоимость передачи по значению включает дополнительное выделение и освобождение памяти — стоимость, которая, скорее всего, превысит стоимость операции по перемещению std::string на порядки.

Интересно, что если старый пароль короче нового, то обычно невозможно избежать при присваивании действий по выделению и освобождению памяти, и в этом случае передача по значению будет выполняться практически с той же скоростью, что и передача по ссылке. Таким образом, стоимость копирования параметров с помощью присваивания может зависеть от объектов, участвующих в присваивании! Этот вид анализа применим к любому типу параметров, который хранит данные в динамически выделенной памяти. Не все типы таковы, но многие — включая std::string и std::vector — обладают этим свойством.

Это потенциальное увеличение стоимости в общем случае применимо только к передаче аргументов, являющихся lvalue, поскольку необходимость выделения и освобождения памяти обычно возникает только тогда, когда выполняется истинное копирование (не перемещение). В случае rvalue-аргументов перемещений почти всегда достаточно.

Получается, что дополнительная стоимость передачи по значению (по сравнению с передачей по ссылке) для функций, копирующих параметр с использованием присваивания, зависит от передаваемого типа, соотношения lvalue- и rvalue-аргументов и от того, использует ли тип динамическую память (и, если использует, то от реализации операторов присваивания для данного типа и вероятности того, что память, связанная с целевым объектом присваивания, как минимум того же размера, что и память присваиваемого объекта). В случае