¿Quieres velocidad? Pasar por valor: consideraciones de rendimiento

El principio de "¿Quieres velocidad? Pasar por valor" sugiere que pasar argumentos por valor a veces puede mejorar el rendimiento debido a la elisión de copia. Para ilustrar, considere el siguiente código usando las clases X e Y:

struct X {
  std::string mem_name;
  X(std::string name) : mem_name(std::move(name)) {}
};

struct Y {
  std::string mem_name;
  Y(const std::string &name) : mem_name(name) {}
};

int main() {
  X(foo());
  Y(foo());
}

Aquí, foo() devuelve una cadena temporal que se pasa a los constructores X e Y. Cuando X inicializa mem_name, invoca el constructor de movimiento de std::string, lo que potencialmente evita copiar la cadena. Sin embargo, cuando Y inicializa mem_name, debe copiar la referencia de cadena.

Argumentos Lvalue vs Rvalue:

Si se pasa un valor l (no temporal), ambos X e Y realizará una copia. Además, X realizará un movimiento. Para rvalues ​​(temporales), X solo puede realizar un movimiento, mientras que Y aún debe realizar una copia.

Implicaciones de rendimiento:

Generalmente, un movimiento es más rápido que pasar un puntero (equivalente a pasar por referencia). Por lo tanto, X tiene un rendimiento similar a Y para valores l y mejor rendimiento para valores r.

Precaución:

Aunque "¿Quieres velocidad? Pasar por valor" es una idea convincente, debe aplicarse con prudencia. Es esencial considerar el contexto específico y los posibles gastos generales asociados con la copia de grandes estructuras de datos. Se recomienda crear perfiles para determinar el impacto real en el rendimiento.

Recursos adicionales:

• [Charla GN13 de Scott Meyer](https://www.youtube.com /watch?v=uk3-zmJWt-E) (marcos temporales 8:10 y 8:56)
• [juanchopanza's Blog: "¿Quieres velocidad? No (siempre) pases por valor"]