Передача по ссылке const или использование семантики перемещения [дубликат]

Являются ли дни прохождения const std :: string & amp; как параметр над?

Нет. Многие люди берут этот совет (включая Дейва Абрахама) за пределы области, к которой он применим, и упрощают его для применения к всем параметрам std::string - Всегда , проходящему через std::string значение не является «лучшей практикой» для любых произвольных параметров и приложений, поскольку оптимизация этих обсуждений / статей сосредоточена на применении только к ограниченному набору случаев .

Если вы 're возвращающее значение, изменяя параметр или принимая значение, тогда передача по значению может сэкономить дорогое копирование и предложить синтаксические удобства.

Как и прежде, передача константой const значительно экономит , когда вы не нужно копировать .

Теперь к конкретному примеру:

Однако inval все еще намного больше размера ссылки (которая обычно реализуется как указатель). Это связано с тем, что std :: string имеет различные компоненты, включая указатель на кучу и член char [] для оптимизации коротких строк. Поэтому мне кажется, что переход по ссылке - это хорошая идея. Может ли кто-нибудь объяснить, почему Herb мог бы это сказать?

Если размер стека является проблемой (и если это не указано / оптимизировано), return_val + inval> return_val - - IOW, использование пикового стека может быть уменьшено , пройдя здесь по значению (обратите внимание: упрощение ABI). Между тем, передача по ссылке const может отключить оптимизацию. Основная причина здесь заключается не в том, чтобы избежать роста стека, а в том, чтобы обеспечить оптимизацию , где это применимо .

Дни прохода по ссылке const не превышают - - правила были сложнее, чем когда-то. Если производительность важна, вам будет разумно рассмотреть, как вы передаете эти типы, на основе сведений, которые вы используете в своих реализациях.

Как отмечает @ JDługosz в комментариях, Херб дает другие советы в другом (позже?) разговоре, см. примерно отсюда: https://youtu.be/xnqTKD8uD64?t=54m50s .

Его совет сводится только к использованию параметров значения для функции f, которая принимает так называемые аргументы стока, предполагая, что вы переместите конструкцию из этих аргументов приемника.

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

void f(T x) {
  T y{std::move(x)};
}

Вызов f с аргументом lvalue приведет к конструктор копирования, вызываемый для построения x, и конструктор перемещения, вызываемый для построения y. С другой стороны, вызов f с аргументом rvalue приведет к вызову конструктора перемещения для построения x и другого конструктора перемещения, который будет вызываться для построения y.

В общем, оптимальная реализация f для аргументов lvalue выглядит следующим образом:

void f(const T& x) {
  T y{x};
}

В этом случае для построения y вызывается только один конструктор копирования. Оптимальная реализация f для аргументов rvalue, опять-таки, в общем случае выглядит следующим образом:

void f(T&& x) {
  T y{std::move(x)};
}

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

Таким образом, разумный компромисс заключается в том, чтобы взять параметр значения и иметь один дополнительный вызов конструктора для аргументов lvalue или rvalue относительно оптимальной реализации, что также является советом, данным в разговоре Херба.

As @ JDługosz отметил в комментариях, передача по значению имеет смысл только для функций, которые будут строить какой-либо объект из аргумента приемника. Когда у вас есть функция f, которая копирует свой аргумент, подход с поправкой будет иметь дополнительные накладные расходы, чем общий метод pass-by-const-reference. Метод pass-by-value для функции f, сохраняющий копию его параметра, будет иметь следующий вид:

void f(T x) {
  T y{...};
  ...
  y = std::move(x);
}

В этом случае есть построение копии и назначение перемещения для аргумент lvalue и конструкцию перемещения и назначение перемещения для аргумента rvalue. Наиболее оптимальным аргументом для аргумента lvalue является:

void f(const T& x) {
  T y{...};
  ...
  y = x;
}

Это сводится только к заданию, которое потенциально намного дешевле, чем конструктор копирования, плюс назначение перемещения, требуемое для подхода с переходом по значению. Причина этого заключается в том, что назначение может повторно использовать существующую выделенную память в y и, следовательно, предотвращать (де) распределения, тогда как конструктор копирования обычно выделяет память.

Для аргумента rvalue наиболее оптимальная реализация для f, который сохраняет копию, имеет вид:

void f(T&& x) {
  T y{...};
  ...
  y = std::move(x);
}

Таким образом, в этом случае назначается только перемещение. Передача rvalue в версию f, которая принимает ссылку const, стоит только присваивание вместо назначения перемещения. Так, условно говоря, предпочтительнее вариант f, принимающий const-ссылку в этом случае как общую реализацию.

Итак, в общем случае для наиболее оптимальной реализации вам нужно будет перегрузить или сделать что-то вроде идеальной пересылки, как показано в разговоре. Недостатком является комбинаторный взрыв в количестве требуемых перегрузок, в зависимости от количества параметров для f, если вы решите перегрузить класс значений аргумента. Идеальная пересылка имеет тот недостаток, что f становится функцией шаблона, которая препятствует ее созданию в виртуальном режиме и приводит к значительно более сложному коду, если вы хотите получить его на 100% вправо (см. Разговор для деталей gory).