Является ли передача по значению разумным значением по умолчанию в C ++ 11?

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

Теперь, в C ++ 11, у нас есть ссылки на Rvalue и конструкторы перемещения, что означает, что можно реализовать большой объект (такой как std::vector), который дешево передавать по значению в функцию и из нее .

Итак, означает ли это, что по умолчанию должен передаваться по значению для экземпляров таких типов, как std::vectorи std::string? Как насчет пользовательских объектов? Какова новая лучшая практика?

Это разумное значение по умолчанию, если вам нужно сделать копию внутри тела. Это то , что Дэйв Абрамс выступает :

Рекомендация: не копируйте аргументы вашей функции. Вместо этого передайте их по значению и позвольте компилятору выполнить копирование.

В коде это означает, что не делайте этого:

void foo(T const& t)
{
    auto copy = t;
    // ...
}

но сделайте это:

void foo(T t)
{
    // ...
}

который имеет преимущество, которое может использовать вызывающий foo сторона так:

T lval;
foo(lval); // copy from lvalue
foo(T {}); // (potential) move from prvalue
foo(std::move(lval)); // (potential) move from xvalue

и только минимальная работа сделана. Вам нужно две перегрузки, чтобы сделать то же самое со ссылками,void foo(T const&); и void foo(T&&);.

Имея это в виду, я теперь написал свои ценные конструкторы как таковые:

class T {
    U u;
    V v;
public:
    T(U u, V v)
        : u(std::move(u))
        , v(std::move(v))
    {}
};

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

Почти во всех случаях ваша семантика должна быть либо:

bar(foo f); // want to obtain a copy of f
bar(const foo& f); // want to read f
bar(foo& f); // want to modify f

Все остальные подписи должны использоваться только экономно и с достаточным основанием. Компилятор теперь всегда будет работать наиболее эффективным способом. Вы можете просто продолжить писать свой код!

Передайте параметры по значению, если внутри тела функции вам нужна копия объекта или вам нужно только переместить объект. Пройти мимоconst& если вам нужен только не мутирующий доступ к объекту.

Пример копирования объекта:

void copy_antipattern(T const& t) { // (Don't do this.)
    auto copy = t;
    t.some_mutating_function();
}

void copy_pattern(T t) { // (Do this instead.)
    t.some_mutating_function();
}

Пример перемещения объекта:

std::vector<T> v; 

void move_antipattern(T const& t) {
    v.push_back(t); 
}

void move_pattern(T t) {
    v.push_back(std::move(t)); 
}

Пример не мутирующего доступа:

void read_pattern(T const& t) {
    t.some_const_function();
}

Для обоснования, см. Эти сообщения в блоге Дэйва Абрахамса и Сян Фана .

Подпись функции должна отражать ее предполагаемое использование. Читаемость важна и для оптимизатора.

Это лучшее предварительное условие для оптимизатора для создания самого быстрого кода - по крайней мере в теории, а если не в реальности, то через несколько лет.

Вопросы производительности очень часто переоцениваются в контексте передачи параметров. Идеальная пересылка - пример. Такие функции, как emplace_backправило, в основном очень короткие и встроенные.