c++ - retornan - parametros por valor y por referencia

¿Pasar por valor es un incumplimiento razonable en C++ 11?

Question

En C ++ tradicional, pasar por valor en funciones y métodos es lento para objetos grandes, y en general es desaprobado. 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 gestión de la memoria (en el caso de que el objeto se asigne en un montón).

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

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

Answer 1

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 solo con moderación y con buena justificación. El compilador ahora casi siempre lo resolverá de la manera más eficiente. ¡Puedes seguir escribiendo tu código!

Answer 2

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

Pauta: no copie los argumentos de su función. En cambio, 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 quien llama puede usar foo así:

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

y solo se hace un trabajo mínimo. Necesitarías 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 const todavía es razonable.

Answer 3

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 por 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 objetos:

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 mayor justificación, vea estas publicaciones de blog de Dave Abrahams y Xiang Fan .