Czy w C++ lepiej przekazać wartość czy przekazać stałą referencję?

Edit: Nowy Artykuł Dave Abrahams na cpp-następny:

Chcesz prędkości? Podaj wartość.

Przekazywanie wartości dla struktur, w których kopiowanie jest tanie, ma dodatkową zaletę, że kompilator może założyć, że obiekty nie są aliasami (nie są tymi samymi obiektami). Używając pass-by-reference kompilator nie może zakładać, że zawsze. Prosty przykład:

foo * f;

void bar(foo g) {
    g.i = 10;
    f->i = 2;
    g.i += 5;
}

Kompilator może zoptymalizować go do

g.i = 15;
f->i = 2;

Ponieważ wie, że f I g nie dzielą to samo miejsce. jeśli g było referencją (foo &), kompilator nie mógł tego zakładać. ponieważ g. i może być aliased przez f- > i I musi mieć wartość 7. więc kompilator musiałby ponownie pobrać nową wartość g. i z pamięci.

Aby uzyskać bardziej praktyczne zasady, poniżej znajduje się dobry zbiór zasad znalezionych w konstruktory ruchu artykuł (wysoce zalecana lektura).

• jeśli funkcja zamierza zmienić argument jako efekt uboczny, weź go przez odniesienie non-const.
• jeśli funkcja nie zmienia swojego argumentu, a argument jest typu prymitywnego, weź go według wartości.
• w przeciwnym razie weź to przez const reference, z wyjątkiem następujących przypadków
  • jeśli funkcja i tak będzie musiała wykonać kopię referencji const, weź ją według wartości.

"prymitywny" powyżej oznacza w zasadzie małe typy danych, które mają kilka bajtów i nie są polimorficzne (Iteratory, obiekty funkcyjne itp...) lub drogie w kopiowaniu. W ta gazeta, jest jeszcze jedna zasada. Chodzi o to, że czasami chce się zrobić kopię (w przypadku, gdy argument nie może być zmodyfikowany), a czasami nie chce (w przypadku, gdy chce się użyć samego argumentu w funkcji, jeśli argument i tak był tymczasowy, na przykład). Artykuł szczegółowo wyjaśnia, w jaki sposób można to zrobić. W C++1x ta technika może być używana natywnie z obsługą języka. Do tego czasu przestrzegałbym powyższych zasad.

Przykłady: aby utworzyć łańcuch wielkich liter i zwracając wersję z dużymi literami, należy zawsze przekazać wartość: trzeba i tak wziąć jej kopię (nie można było zmienić bezpośrednio referencji const) - więc lepiej uczynić ją tak przejrzystą, jak to możliwe dla wywołującego i wykonać tę kopię wcześniej, aby wywołujący mógł zoptymalizować tak bardzo, jak to możliwe - jak szczegółowo opisano w tym artykule: {]}

my::string uppercase(my::string s) { /* change s and return it */ }

Jeśli jednak nie musisz zmieniać parametru, weź go przez odniesienie do const:

bool all_uppercase(my::string const& s) { 
    /* check to see whether any character is uppercase */
}

Jeśli jednak celem parametru jest napisz coś do argumentu, a następnie przekaż go przez referencję non-const

bool try_parse(T text, my::string &out) {
    /* try to parse, write result into out */
}

Zależy od typu. Dodajesz mały narzut z konieczności dokonania odniesienia i dereferencji. Dla typów o rozmiarze równym lub mniejszym niż wskaźniki, które używają domyślnej kopii ctor, prawdopodobnie szybciej byłoby przekazać wartość.

Jak już wspomniano, zależy to od typu. W przypadku wbudowanych typów danych najlepiej jest przekazać wartość. Nawet niektóre bardzo małe struktury, takie jak para int mogą działać lepiej, przechodząc przez wartość.

Oto przykład, załóżmy, że masz wartość całkowitą i chcesz przekazać ją do innej procedury. Jeśli ta wartość została zoptymalizowana do przechowywania w Rejestrze, to jeśli chcesz przekazać ją jako referencję, najpierw musi być zapisana w pamięci, a następnie wskaźnik do tej pamięci umieszczony na stos do wykonania połączenia. Jeśli był przekazywany przez wartość, wszystko, co jest wymagane, to rejestr wypchnięty na stos. (Szczegóły są nieco bardziej skomplikowane niż w przypadku różnych systemów wywołujących i procesorów).

Jeśli zajmujesz się programowaniem szablonów, Zwykle jesteś zmuszony do podania const ref, ponieważ nie wiesz, jakie typy są przekazywane. Kary za przekazanie czegoś złego przez wartość są znacznie gorsze niż kary za przekazanie wbudowanego typu przez const Nr ref.

Wygląda na to, że masz swoją odpowiedź. Przekazywanie wartości jest kosztowne, ale daje kopię do pracy, jeśli jej potrzebujesz.

Z reguły przechodzenie przez referencję const jest lepsze. Ale jeśli chcesz zmodyfikować argument funkcji lokalnie, powinieneś lepiej użyć wartości passing by. W przypadku niektórych podstawowych typów wydajność w ogóle taka sama zarówno dla przekazywania przez wartość, jak i przez odniesienie. W rzeczywistości Referencja wewnętrznie reprezentowana przez wskaźnik, dlatego można oczekiwać na przykład, że dla wskaźnika oba przejścia są takie same pod względem wydajności, lub nawet przekazywanie przez wartość może być szybsze z powodu niepotrzebnej dereferencji.

To jest to, co zwykle pracuję przy projektowaniu interfejsu funkcji nie-szablonowej:

1. Przekazać wartość, jeśli funkcja nie chce modyfikować parametru i wartość jest tania w kopiowaniu (int, double, float, char, bool, itp... Zauważ, że std:: string, std:: vector i reszta kontenerów w bibliotece standardowej nie są)

2. Przechodzić przez wskaźnik const, jeśli wartość jest kosztowna do skopiowania, a funkcja robi nie chcesz modyfikować wskazywanej wartości a NULL jest wartością, którą obsługuje funkcja.

3. Przechodzić przez wskaźnik non-const, jeśli wartość jest kosztowna do skopiowania, a funkcja chce zmodyfikować wskazywaną wartość, a NULL jest wartością obsługiwaną przez funkcję.

4. Przekazuje referencję const, gdy wartość jest kosztowna do skopiowania, a funkcja nie chce modyfikować wartości, o której mowa, a NULL nie byłaby prawidłową wartością, gdyby zamiast niej użyto wskaźnika.

5. Przekazać przez odniesienie non-const, gdy wartość jest kosztowna w kopiowaniu i funkcja chce zmodyfikować wartość, o której mowa, a NULL nie byłaby poprawną wartością, gdyby zamiast niej użyto wskaźnika.

Jako zasada, wartość dla typów nieklasowych i const reference dla klas. Jeśli klasa jest naprawdę mała, prawdopodobnie lepiej przekazać wartość, ale różnica jest minimalna. To, czego naprawdę chcesz uniknąć, to przekazywanie jakiejś gigantycznej klasy po wartości i powielanie jej wszystkich - to zrobi ogromną różnicę, jeśli przechodzisz, powiedzmy, std::vector z kilkoma elementami w nim.

Podaj wartość dla małych typów.

Przekazywanie referencji const dla typów dużych (definicja big może się różnić w zależności od maszyn), ale w C++11 przekazywanie wartości, jeśli chcesz zużyć dane, ponieważ możesz wykorzystać semantykę move. Na przykład:

class Person {
 public:
  Person(std::string name) : name_(std::move(name)) {}
 private:
  std::string name_;
};

Teraz kod wywoławczy zrobi:

Person p(std::string("Albert"));

I tylko jeden obiekt zostałby utworzony i przeniesiony bezpośrednio do członka name_ w klasie Person. Jeśli przejdziesz obok const reference, trzeba będzie wykonać kopię, aby umieścić ją w name_.

Prosta różnica: - w funkcji mamy parametr wejściowy i wyjściowy, więc jeśli twój parametr wejściowy i wyjściowy jest taki sam, Użyj wywołania przez odniesienie, inaczej jeśli parametr wejściowy i wyjściowy są różne, lepiej użyć wywołania przez wartość .

Przykład void amount(int account , int deposit , int total )

Parametr wejściowy: konto, wpłata parametr wyjściowy: total

Input i out to różne use call by vaule

1. void amount(int total , int deposit )

Input total deposit output total