¿El paso por valor es un valor predeterminado razonable en C ++ 11?

En C ++ tradicional, pasar por valor a funciones y métodos es lento para objetos grandes, y generalmente está mal visto. En cambio, los programadores de C ++ tienden a pasar referencias, lo que es más rápido, pero que introduce todo tipo de preguntas complicadas sobre la propiedad y especialmente sobre la administración de memoria (en el caso de que el objeto esté asignado en un montón)

Ahora, en C ++ 11, tenemos referencias de Rvalue y constructores de movimiento, lo que significa que es posible implementar un objeto grande (como un std::vector) que es barato pasar por valor dentro y fuera de una función.

Entonces, ¿esto significa que el valor predeterminado debería ser pasar por valor para instancias de tipos como std::vectory std::string? ¿Qué pasa con los objetos personalizados? ¿Cuál es la nueva mejor práctica?

Es un valor predeterminado razonable si necesita hacer una copia dentro del cuerpo. Esto es lo que Dave Abrahams defiende :

Pauta: no copie los argumentos de su función. En su lugar, páselos por valor y deje que el compilador haga la copia.

En código esto significa que no hagas esto:

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

pero haz esto:

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

que tiene la ventaja de que la persona que llama puede usar fooasí:

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

y solo se realiza un trabajo mínimo. Necesitaría dos sobrecargas para hacer lo mismo con las referencias, void foo(T const&);y void foo(T&&);.

Con eso en mente, ahora escribí mis valiosos constructores como tales:

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

De lo contrario, pasar por referencia a consttodavía es razonable.

En casi todos los casos, su semántica debe 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 las demás firmas deben usarse con moderación y con buena justificación. El compilador ahora casi siempre los resolverá de la manera más eficiente. ¡Puedes seguir escribiendo tu código!

Pase los parámetros por valor si dentro del cuerpo de la función necesita una copia del objeto o solo necesita mover el objeto. Pase const&si solo necesita acceso no mutante al objeto.

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

Ejemplo de movimiento 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)); 
}

Ejemplo de acceso no mutante:

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

Para una explicación, vea estas publicaciones de blog de Dave Abrahams y Xiang Fan .

La firma de una función debe reflejar su uso previsto. La legibilidad es importante, también para el optimizador.

Esta es la mejor condición previa para que un optimizador cree un código más rápido, al menos en teoría y, si no en la realidad, en unos pocos años.

Las consideraciones de rendimiento a menudo se sobrevaloran en el contexto del paso de parámetros. El reenvío perfecto es un ejemplo. Las funciones como emplace_backson en su mayoría muy cortas e integradas de todos modos.