Zalety pass-by-value i std :: move w porównaniu z pass-by-reference

W tej chwili uczę się C ++ i staram się unikać złych nawyków. Z tego, co rozumiem, clang-tidy zawiera wiele „najlepszych praktyk” i staram się ich trzymać jak najlepiej (chociaż niekoniecznie rozumiem, dlaczego są jeszcze uważane za dobre), ale nie jestem pewien, czy zrozumieć, co jest tutaj zalecane.

Użyłem tej klasy z samouczka:

class Creature
{
private:
    std::string m_name;

public:
    Creature(const std::string &name)
            :  m_name{name}
    {
    }
};

Prowadzi to do sugestii ze strony clang-tidy, że powinienem przekazywać wartości zamiast odniesienia i używania std::move. Jeśli to zrobię, namepojawia się sugestia, aby zrobić odniesienie (aby upewnić się, że nie zostanie skopiowana za każdym razem) i ostrzeżenie, std::movektóre nie będzie miało żadnego efektu, ponieważ namejest consttak, więc powinienem je usunąć.

Jedynym sposobem, w jaki nie otrzymuję ostrzeżenia, jest constcałkowite usunięcie :

Creature(std::string name)
        :  m_name{std::move(name)}
{
}

Wydaje się to logiczne, ponieważ jedyną korzyścią constbyło zapobieganie pomieszaniu z oryginalnym ciągiem (co nie ma miejsca, ponieważ przekazałem wartość). Ale czytałem na CPlusPlus.com :

Chociaż należy zauważyć, że -w standardowej bibliotece-przeniesienie oznacza, że ​​obiekt przeniesiony-z pozostaje w prawidłowym, ale nieokreślonym stanie. Co oznacza, że ​​po takiej operacji wartość przenoszonego obiektu powinna zostać jedynie zniszczona lub przypisana nowa wartość; dostęp do niego w przeciwnym razie daje nieokreśloną wartość.

Teraz wyobraź sobie ten kod:

std::string nameString("Alex");
Creature c(nameString);

Ponieważ nameStringzostanie przekazany przez wartość, std::moveunieważni tylko namewewnątrz konstruktora i nie dotknie oryginalnego ciągu. Ale jakie są z tego zalety? Wygląda na to, że treść jest kopiowana tylko raz - jeśli przekażę przez odwołanie, gdy wywołuję m_name{name}, jeśli przekażę wartość, gdy ją przekażę (a następnie zostanie przeniesiona). Rozumiem, że jest to lepsze niż przekazywanie wartości i nie używanie std::move(ponieważ jest dwukrotnie kopiowane).

Więc dwa pytania:

1. Czy dobrze zrozumiałem, co się tutaj dzieje?
2. Czy jest jakaś korzyść z używania std::moveprzekazywania przez referencję i po prostu dzwoniąc m_name{name}?

1. Czy dobrze zrozumiałem, co się tutaj dzieje?

Tak.

2. Czy jest jakaś korzyść z używania std::moveprzekazywania przez referencję i po prostu dzwoniąc m_name{name}?

Łatwy do uchwycenia podpis funkcji bez dodatkowych przeciążeń. Podpis natychmiast ujawnia, że ​​argument zostanie skopiowany - dzięki temu wywołujący nie zastanawiają się, czy const std::string&referencja może być przechowywana jako element członkowski danych, a być może później stanie się referencją wiszącą. I nie ma potrzeby przeciążania argumentów std::string&& namei przeciążania, const std::string&aby uniknąć niepotrzebnych kopii, gdy rvalues ​​są przekazywane do funkcji. Przekazywanie lwartości

std::string nameString("Alex");
Creature c(nameString);

do funkcji, która przyjmuje argument przez wartość, powoduje jedną kopię i jeden ruch. Przekazywanie wartości r do tej samej funkcji

std::string nameString("Alex");
Creature c(std::move(nameString));

powoduje dwie konstrukcje ruchu. W przeciwieństwie do tego, gdy parametr funkcji ma wartość const std::string&, zawsze będzie kopia, nawet w przypadku przekazania argumentu rvalue. Jest to niewątpliwie zaleta, o ile typ argumentu jest tani w konstrukcji przenoszenia (tak jest w przypadku std::string).

Ale jest wada do rozważenia: rozumowanie nie działa dla funkcji, które przypisują argument funkcji do innej zmiennej (zamiast ją inicjować):

void setName(std::string name)
{
    m_name = std::move(name);
}

spowoduje cofnięcie alokacji zasobu, m_namedo którego się odwołuje, przed ponownym przypisaniem. Polecam przeczytanie pozycji 41 w Effective Modern C ++, a także to pytanie .

/* (0) */ 
Creature(const std::string &name) : m_name{name} { }

• Przekazana lwartość wiąże się z name, a następnie jest kopiowana do m_name.

• Przekazana wartość r wiąże się z name, a następnie jest kopiowana do m_name.

/* (1) */ 
Creature(std::string name) : m_name{std::move(name)} { }

• Przekazana lwartość jest kopiowana do name, a następnie przenoszona do m_name.

• Przekazana wartość r jest przenoszona do name, a następnie przenoszona do m_name.

/* (2) */ 
Creature(const std::string &name) : m_name{name} { }
Creature(std::string &&rname) : m_name{std::move(rname)} { }

• Przekazana lwartość wiąże się z name, a następnie jest kopiowana do m_name.

• Przekazana wartość r wiąże się z rname, a następnie jest przenoszona do m_name.

Ponieważ operacje przenoszenia są zwykle szybsze niż kopiowanie, (1) jest lepsze niż (0), jeśli podajesz wiele tymczasowych. (2) jest optymalny pod względem kopii / ruchów, ale wymaga powtórzenia kodu.

Powtarzania kodu można uniknąć dzięki doskonałemu przekazywaniu :

/* (3) */
template <typename T,
          std::enable_if_t<
              std::is_convertible_v<std::remove_cvref_t<T>, std::string>, 
          int> = 0
         >
Creature(T&& name) : m_name{std::forward<T>(name)} { }

Opcjonalnie możesz chcieć ograniczyć T, aby ograniczyć domenę typów, z których można utworzyć wystąpienie tego konstruktora (jak pokazano powyżej). C ++ 20 ma na celu uproszczenie tego za pomocą Concepts .

W C ++ 17 na prvalues wpływa gwarantowana elisja kopiowania , która - w stosownych przypadkach - zmniejszy liczbę kopii / ruchów podczas przekazywania argumentów do funkcji.

To , jak mijasz, nie jest jedyną zmienną tutaj, to , co mijasz, stanowi dużą różnicę między nimi.

W C ++ mamy wszystkie rodzaje kategoriach wartości i istnieje ta „idiom” dla przypadków, gdzie przechodzą w rvalue (takiego jak "Alex-string-literal-that-constructs-temporary-std::string"lub std::move(nameString)), co skutkuje 0 egzemplarzach z std::stringodniesienia (typ nawet nie muszą być kopiowaniem constructible dla argumentów rvalue) i używa tylko std::stringkonstruktora przenoszenia.

Dość powiązane pytania i odpowiedzi .

Istnieje kilka wad podejścia pass-by-value-and-move względem odniesienia pass-by- (rv):

• powoduje, że pojawiają się 3 obiekty zamiast 2;
• przekazywanie obiektu przez wartość może prowadzić do dodatkowego obciążenia stosu, ponieważ nawet zwykła klasa łańcuchowa jest zwykle co najmniej 3 lub 4 razy większa niż wskaźnik;
• konstrukcja obiektów argumentowych będzie wykonywana po stronie wywołującego, powodując rozdęcie kodu;

W moim przypadku przełączenie na przekazanie według wartości, a następnie wykonanie std: move spowodowało błąd sterty-use-after-free w programie Address Sanitizer.

https://travis-ci.org/github/acgetchell/CDT-plusplus/jobs/679520360#L3165

Więc wyłączyłem go, a także sugestię w porządku.

https://github.com/acgetchell/CDT-plusplus/compare/80c96789f0a2...0d78fd63b332