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

) тип передаваемого функции элемента представляет собой std::string. В конце концов, именно этот тип хранится в контейнере.

Несмотря на всю логичность, это не всегда верно. Рассмотрим следующий код:

std::vector vs; // Контейнер std::string
vs.push_back("xyzzy");       // Добавление строкового литерала

Здесь контейнер хранит строки std::string, но в действительности вы передаете в функцию push_back строковый литерал, т.e. последовательность символов в двойных кавычках. Строковый литерал не является std::string, и это означает, что переданный вами в функцию push_back аргумент имеет тип, отличный от типа элементов, хранящихся в контейнере.

Функция push_back класса std::vector перегружена для lvalue и rvalue следующим образом:

template
          class Allocator = allocator> // C++11
class vector {
public:
 …
 void push_back(const T& x);              // Вставка lvalue
 void push_back(T&& x);                   // Вставка rvalue

};

В вызове

vs.push_back("xyzzy");

компиляторы видят несоответствие между типом аргумента (const char[6]) и типом параметра, получаемого функцией push_back (ссылка на std::string). Они разрешают это несоответствие путем генерации кода для создания временного объекта std::string из строкового литерала и передачи этого временного объекта функции push_back. Другими словами, они рассматривают вызов так, как будто он записан следующим образом:

vs.push_back(std::string("xyzzy")); // Создание временного
// объекта std::string и передача его функции push_back

Этот код компилируется и выполняется, и все расходятся счастливыми и довольными. Все, кроме свихнувшихся на производительности программистов, которые обнаруживают, что этот код не настолько эффективен, насколько должен быть.

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

1. Из строкового литерала "xyzzy" создается временный объект std::string. Этот объект не имеет имени; назовем его temp. Создание temp представляет собой первое конструирование std::string. Поскольку это временный объект, temp представляет собой rvalue.

2. Объект temp передается в rvalue-перегрузку push_back, где он связывается с параметром x, представляющим собой rvalue-ссылку. Затем в памяти std::vector создается копия x. Это второе конструирование действительно создает новый объект внутри std::vector. (Конструктор, использованный для копирования x в std::vector, представляет собой перемещающий конструктор, поскольку x, будучи rvalue-ссылкой, приводится к rvalue перед копированием. Информацию о приведении параметров, являющихся rvalue-ссылками, в rvalue можно найти в разделе 5.3.)

3. Непосредственно после возврата из push_back уничтожается объект temp; при этом вызывается деструктор std::string.

Фанаты производительности не в состоянии помочь, но замечают, что если бы был способ взять строковый литерал и непосредственно передать его в код шага 2, который конструирует объект std::string внутри std::vector, то можно было бы избежать конструирования и удаления temp. Это могло бы оказаться максимально эффективным подходом.

Поскольку вы программист на С++, шанс, что вы фанат производительности, явно выше среднего. Если вы не из таких, то, пожалуй, все равно им симпатизируете. (Если же производительность вас не интересует, может, вы просто ошиблись дверью? Python находится дальше по коридору…) Так что я рад сообщить вам, что есть способ сделать именно то, что требуется для достижения максимальной эффективности в вызове push_back. Это — не вызывать push_back. Функция push_back неправильная. Вам нужна функция emplace_back.

Функция emplace_back делает именно то, что мы хотим: использует переданный аргумент для конструирования std::string непосредственно внутри std::vector, не прибегая ни к каким временным объектам:

vs.emplace_back("xyzzy"); // Создает std::string в vs
                          // непосредственно из "xyzzy"

emplace_back использует прямую передачу, так что до тех пор, пока вы не столкнетесь с одним из ограничений прямой передачи (раздел 5.8), можете передавать любое количество аргументов с любой комбинацией типов. Например, если вы хотите создать std::string в vs с помощью конструктора std::string, получающего символ и количество его повторений, то вы пишете следующий исходный текст:

vs.emplace_back(50, 'x'); // Вставка std::string из
                          // 50 символов 'x'

Функция emplace_back доступна во всех стандартных контейнерах, которые поддерживают push_back. Аналогично каждый стандартный контейнер, который поддерживает push_front, поддерживает и emplace_front. И каждый стандартный контейнер, поддерживающий insert (т.e. все контейнеры, кроме std::forward_list и std::array), поддерживает emplace. Ассоциативные контейнеры предоставляют emplace_hint в качестве дополнения к функциям