Передавать по значению или ссылке в конструктор C ++, которому необходимо сохранить копию?

В C ++ 98 и C ++ 03 вы должны передать const& bar, а затем скопировать. В C ++ 0x вы должны передать bar, а затем выполнить перемещение (при условии, что bar имеет конструктор перемещения).

#include <utility>

struct foo
{
    bar _b;

    foo(bar b) : _b(std::move(b)) {}
};

Если вы создаете foo с параметром lvalue, конструктор копирования будет вызван для создания копии b, и эта копия будет перемещена в _b. Если вы создаете foo с параметром rvalue, будет вызван конструктор перемещения bar для перемещения в b, а затем он снова будет перемещен в _b.

При прочих равных я прохожу через const & для достаточно сложных классов и value для POD и простых объектов.

Выделение плюсов и минусов для передачи по константной ссылке вместо традиционной передачи по значению

Положительные:

• Избегает копирования (большой плюс для объектов с дорогой копией)
• Доступ только для чтения

Минус:

• Кто-то может удалить константу из ссылки, если они действительно хотят

Что еще более важно с положительными моментами, вы явно контролируете, когда происходит копирование (в вашем случае при передаче инициализации _b в вашем списке инициализаторов). Думая о негативе ... Согласен, это риск. Я думаю, что почти все хорошие программисты почувствуют себя грязными при использовании const_cast. Более того, вы можете послушно искать const_cast и бросать помидоры в человека, отбрасывающего константу из аргумента. Но эй, как знать, а у кого есть время смотреть код как ястреб :)?

Мое субъективное мнение таково, что в достаточно сложных классах и в средах, где производительность имеет значение, выгода от отказа от конструктора копирования перевешивает риск. Однако для действительно глупых классов и POD я обычно делаю копии данных и передаю их по значению.

Посмотрите этот вопрос.

Используйте const T & arg, если sizeof(T)>sizeof(void*), и T arg, если sizeof(T) <= sizeof(void*). Все основные типы должны быть исключением из этого правила.

Стилистически я бы сказал, что передача по ссылке - лучший способ.

Если производительность действительно имеет значение, не гадайте. Измерьте это.

Я не проверял, что говорится в стандарте, но, попробовав это эмпирически, могу сказать вам, что GCC не оптимизирует копию, независимо от того, принимает ли конструктор аргумент по значению или по константной ссылке.

Однако, если конструктор принимает ссылку на константу, ему удается избежать ненужной копии при создании foo из существующего объекта bar.

Обобщить:

Bar b = makeBar();         // No copy, because of RVO
FooByValue f1 = makeBar(); // Copy constructor of Bar called once
FooByRef f2 = makeBar();   // Copy constructor of Bar called once
FooByValue f3(b);          // Copy constructor of Bar called twice
FooByRef f4(b);            // Copy constructor of Bar called only once

Не то чтобы я являюсь экспертом по компиляторам, но, думаю, имеет смысл, что обычно он не может преобразовать возвращаемое значение в произвольное место (например, в поле member объекта foo). Вместо этого требуется, чтобы цель находилась наверху стека.

Я предполагаю, что bar имеет нормальный конструктор копирования в форме bar(const bar &b)

Возьмите здесь константную ссылку. Затем конструктор bar возьмет эту ссылку и выполнит копирование. Всего копий: 1.

Если вы не указали ссылку, компилятор сделает копию b, передаст копию конструктору foo, который затем передаст ее bar и скопирует.

Честно говоря, для этого случая лучшим вариантом является создание вашего конструктора inline при условии, что конструктор bar не генерирует. Тогда просто пройдите по ссылке.

Кроме того, как вы и подозревали, ваша статья здесь не применяется.

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