A passagem por valor é um padrão razoável no C ++ 11?

No C ++ tradicional, a passagem de valor para funções e métodos é lenta para objetos grandes e geralmente é desaprovada. Em vez disso, os programadores de C ++ tendem a passar referências, o que é mais rápido, mas apresenta todos os tipos de perguntas complicadas sobre propriedade e principalmente sobre gerenciamento de memória (no caso de o objeto ser alocado por heap)

Agora, no C ++ 11, temos referências Rvalue e movemos construtores, o que significa que é possível implementar um objeto grande (como um std::vector) que é barato para passar valor por uma função.

Então, isso significa que o padrão deve ser passar valor para instâncias de tipos como std::vectore std::string? E os objetos personalizados? Qual é a nova melhor prática?

É um padrão razoável se você precisar fazer uma cópia dentro do corpo. Isto é o que Dave Abrahams está defendendo :

Diretriz: Não copie seus argumentos de função. Em vez disso, passe-os por valor e deixe o compilador fazer a cópia.

No código, isso significa não fazer isso:

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

mas faça o seguinte:

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

qual tem a vantagem que o chamador pode usar fooassim:

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

e apenas um trabalho mínimo é feito. Você precisaria de duas sobrecargas para fazer o mesmo com referências void foo(T const&);e void foo(T&&);.

Com isso em mente, agora escrevi meus valiosos construtores como tais:

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

Caso contrário, passar por referência a conststill é razoável.

Em quase todos os casos, sua semântica deve ser:

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

Todas as outras assinaturas devem ser usadas apenas com moderação e com boa justificativa. O compilador agora praticamente sempre trabalha isso da maneira mais eficiente. Você pode simplesmente escrever seu código!

Passe parâmetros por valor se, dentro do corpo da função, você precisar de uma cópia do objeto ou apenas precisar movê-lo. Passe const&se você precisar apenas de acesso sem mutação ao objeto.

Exemplo de cópia de objeto:

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();
}

Exemplo de movimentação de objeto:

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)); 
}

Exemplo de acesso sem mutação:

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

Para justificativa, consulte as postagens de Dave Abrahams e Xiang Fan .

A assinatura de uma função deve refletir seu uso pretendido. A legibilidade é importante, também para o otimizador.

Essa é a melhor pré-condição para um otimizador criar código mais rápido - pelo menos em teoria e, se não na realidade, em alguns anos.

As considerações de desempenho são muitas vezes superestimadas no contexto da passagem de parâmetros. O encaminhamento perfeito é um exemplo. Funções como a emplace_backmaioria são muito curtas e alinhadas de qualquer maneira.