Quer velocidade? Passagem por valor: considerações de desempenho

O princípio "Quer velocidade? Passagem por valor" sugere que passar argumentos por valor às vezes pode melhorar o desempenho devido à elisão de cópia. Para ilustrar, considere o seguinte código usando as classes 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());
}

Aqui, foo() retorna uma string temporária que é passada para os construtores X e Y. Quando X inicializa mem_name, ele invoca o construtor de movimento de std::string, o que potencialmente evita a cópia da string. No entanto, quando Y inicializa mem_name, ele deve copiar a referência da string.

Lvalue vs Rvalue Argumentos:

Se um lvalue (não temporário) for passado, ambos X e Y fará uma cópia. Além disso, X realizará um movimento. Para rvalues ​​(temporários), X só pode realizar um movimento, enquanto Y ainda deve realizar uma cópia.

Implicações de desempenho:

Geralmente, um movimento é mais rápido do que passar um ponteiro (equivalente a passar por referência). Portanto, X tem desempenho semelhante a Y para lvalues ​​e melhor desempenho para rvalues.

Cuidado:

Embora "Quer velocidade? Passar por valor" seja uma ideia atraente, deve ser aplicado criteriosamente. É essencial considerar o contexto específico e a sobrecarga potencial associada à cópia de grandes estruturas de dados. A criação de perfil é recomendada para determinar o impacto real no desempenho.

Recursos adicionais:

• [Scott Meyer's GN13 Talk](https://www.youtube.com /watch?v=uk3-zmJWt-E) (períodos 8:10 e 8:56)
• [juanchopanza's Blog: "Quer velocidade? Não passe (sempre) pelo valor"]