Il pass-by-value è un valore predefinito ragionevole in C ++ 11?

Nel C ++ tradizionale, passare per valore in funzioni e metodi è lento per oggetti di grandi dimensioni e generalmente non viene visto. Invece, i programmatori C ++ tendono a passare i riferimenti in giro, che è più veloce, ma che introduce ogni sorta di domande complicate sulla proprietà e in particolare sulla gestione della memoria (nel caso in cui l'oggetto sia allocato in heap)

Ora, in C ++ 11, abbiamo riferimenti a Rvalue e spostiamo i costruttori, il che significa che è possibile implementare un oggetto di grandi dimensioni (come un std::vector) che è economico per passare da un valore all'altro in una funzione.

Quindi, ciò significa che il valore predefinito dovrebbe essere passare per valore per istanze di tipi come std::vectore std::string? Che dire di oggetti personalizzati? Qual è la nuova migliore pratica?

È un valore predefinito ragionevole se è necessario effettuare una copia all'interno del corpo. Questo è ciò che Dave Abrahams sta sostenendo :

Linea guida: non copiare gli argomenti della funzione. Invece, passali per valore e lascia che il compilatore esegua la copia.

Nel codice questo significa non farlo:

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

ma fai questo:

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

che ha il vantaggio che il chiamante può usare in questo foomodo:

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

e viene svolto solo un lavoro minimo. Avresti bisogno di due sovraccarichi per fare lo stesso con i riferimenti void foo(T const&);e void foo(T&&);.

Con questo in mente, ora ho scritto i miei stimati costruttori come tali:

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

Altrimenti, passare per riferimento a constStill è ragionevole.

In quasi tutti i casi, la semantica dovrebbe essere:

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

Tutte le altre firme dovrebbero essere usate solo con parsimonia e con una buona giustificazione. Il compilatore ora quasi sempre li risolverà nel modo più efficiente. Puoi continuare a scrivere il tuo codice!

Passa i parametri per valore se all'interno del corpo della funzione hai bisogno di una copia dell'oggetto o devi solo spostare l'oggetto. Passa const&se hai bisogno solo di un accesso non mutante all'oggetto.

Esempio di copia dell'oggetto:

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

Esempio di spostamento dell'oggetto:

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

Esempio di accesso non mutante:

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

Per ragioni logiche, vedi questi post sul blog di Dave Abrahams e Xiang Fan .

La firma di una funzione dovrebbe riflettere l'uso previsto. La leggibilità è importante, anche per l'ottimizzatore.

Questo è il miglior presupposto per un ottimizzatore per creare il codice più veloce - almeno in teoria e se non nella realtà, poi tra qualche anno la realtà.

Le considerazioni sulle prestazioni sono spesso sopravvalutate nel contesto del passaggio dei parametri. L'inoltro perfetto è un esempio. Le funzioni come emplace_backsono per lo più molto brevi e in linea comunque.