Czy wartość przekazywana jest rozsądną wartością domyślną w C ++ 11?

W tradycyjnym C ++ przekazywanie wartości do funkcji i metod jest powolne w przypadku dużych obiektów i generalnie jest źle widziane. Zamiast tego programiści C ++ mają tendencję do przekazywania referencji, co jest szybsze, ale wprowadza różnego rodzaju skomplikowane pytania dotyczące własności, a zwłaszcza zarządzania pamięcią (w przypadku, gdy obiekt jest alokowany na stosie)

Teraz w C ++ 11 mamy referencje Rvalue i konstruktory przenoszenia, co oznacza, że ​​można zaimplementować duży obiekt (taki jak std::vector), który jest tani do przekazywania wartości do i z funkcji.

Czy to oznacza, że ​​wartością domyślną powinno być przekazywanie wartości dla wystąpień typów, takich jak std::vectori std::string? A co z obiektami niestandardowymi? Jaka jest nowa najlepsza praktyka?

Jest to rozsądne ustawienie domyślne, jeśli chcesz wykonać kopię wewnątrz ciała. Oto, za czym opowiada się Dave Abrahams :

Wskazówka: nie kopiuj argumentów funkcji. Zamiast tego przekaż je według wartości i pozwól kompilatorowi wykonać kopiowanie.

W kodzie oznacza to, że nie rób tego:

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

ale zrób to:

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

który ma tę zaletę, że dzwoniący może używać w następujący foosposób:

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

i tylko minimalna praca jest wykonywana. Potrzebujesz dwóch przeciążeń, aby zrobić to samo z odwołaniami, void foo(T const&);i void foo(T&&);.

Mając to na uwadze, napisałem teraz moich cenionych konstruktorów jako takich:

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

W przeciwnym razie przekazanie przez odniesienie do constnadal jest rozsądne.

W prawie wszystkich przypadkach Twoja semantyka powinna wyglądać następująco:

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

Wszystkie inne podpisy powinny być używane oszczędnie i z dobrym uzasadnieniem. Kompilator będzie teraz prawie zawsze rozwiązywać je w najbardziej efektywny sposób. Możesz po prostu kontynuować pisanie kodu!

Przekaż parametry według wartości, jeśli w treści funkcji potrzebujesz kopii obiektu lub musisz tylko przenieść obiekt. Pomiń, const&jeśli potrzebujesz tylko niemutującego dostępu do obiektu.

Przykład kopii obiektu:

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

Przykład przeniesienia obiektu:

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

Przykład dostępu bez mutacji:

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

Dla uzasadnienia zobacz te posty na blogu autorstwa Dave'a Abrahamsa i Xiang Fan .

Podpis funkcji powinien odzwierciedlać jej przeznaczenie. Czytelność jest ważna, także dla optymalizatora.

Jest to najlepszy warunek wstępny dla optymalizatora do stworzenia najszybszego kodu - przynajmniej w teorii, a jeśli nie w rzeczywistości, to za kilka lat.

Zagadnienia dotyczące wydajności są bardzo często przeceniane w kontekście przekazywania parametrów. Przykładem jest perfekcyjna spedycja. Funkcje takie jak emplace_backsą przeważnie bardzo krótkie i tak czy inaczej wbudowane.