Co to jest std :: move () i kiedy należy go używać?

1. Co to jest?
2. Co to robi?
3. Kiedy należy go używać?

Doceniamy dobre linki.

Strona Wikipedii na temat C ++ 11 Odnośniki do wartości R i konstruktory ruchów

1. W C ++ 11, oprócz konstruktorów kopiowania, obiekty mogą mieć konstruktory ruchów.
   (Oprócz operatorów kopiowania przypisania mają także operatory przypisania przeniesienia).
2. Konstruktor ruchu jest używany zamiast konstruktora kopiowania, jeśli obiekt ma typ „rvalue-reference” ( Type &&).
3. std::move() jest rzutowaniem, które generuje odwołanie do wartości do obiektu, aby umożliwić poruszanie się z niego.

Jest to nowy sposób C ++ pozwalający uniknąć kopii. Na przykład, używając konstruktora przenoszenia, a std::vectormoże po prostu skopiować swój wewnętrzny wskaźnik do danych do nowego obiektu, pozostawiając przeniesiony obiekt w stanie przeniesionym ze stanu, a zatem nie kopiując wszystkich danych. To byłoby C ++ - poprawne.

Spróbuj googlingu, aby uzyskać semantykę ruchu, wartość rue, doskonałe przekazywanie.

1. „Co to jest?”

Chociaż std::move() technicznie jest to funkcja - powiedziałbym, że tak naprawdę nie jest funkcją . Jest to rodzaj konwertera między sposobami, w których kompilator uwzględnia wartość wyrażenia.

2. „Co to robi?”

Pierwszą rzeczą, na którą należy zwrócić uwagę, jest to, że std::move() tak naprawdę nic nie rusza . Konwertuje wyrażenie od bycia lwartość (takich jak zmiennej o nazwie) do bycia xvalue . Wartość x mówi kompilatorowi:

Możesz mnie ograbić, przenieść wszystko, co trzymam i użyć go gdzie indziej (bo i tak wkrótce mnie zniszczą).

innymi słowy, kiedy używasz std::move(x), pozwalasz kompilatorowi na kanibalizację x. Zatem jeśli x, powiedzmy, ma własny bufor w pamięci - po std::move()kompilacji może zamiast niego posiadać inny obiekt.

_{Możesz także przejść z prvalue (np. Tymczasowego mijania), ale jest to rzadko przydatne.}

3. „Kiedy należy go użyć?”

Innym sposobem na zadanie tego pytania jest: „Po co miałbym kanibalizować zasoby istniejącego obiektu?” cóż, jeśli piszesz kod aplikacji, prawdopodobnie nie będziesz się zbytnio bawić w tymczasowe obiekty tworzone przez kompilator. Zasadniczo robiłbyś to w miejscach takich jak konstruktory, metody operatora, funkcje podobne do algorytmów biblioteki standardowej itp., W których obiekty są często tworzone i niszczone automatycznie. Oczywiście to tylko ogólna zasada.

Typowym zastosowaniem jest „przenoszenie” zasobów z jednego obiektu do drugiego zamiast kopiowania. @Guillaume prowadzi do tej strony, która ma prosty krótki przykład: zamiana dwóch obiektów przy mniejszym kopiowaniu.

template <class T>
swap(T& a, T& b) {
    T tmp(a);   // we now have two copies of a
    a = b;      // we now have two copies of b (+ discarded a copy of a)
    b = tmp;    // we now have two copies of tmp (+ discarded a copy of b)
}

użycie move pozwala zamienić zasoby zamiast je kopiować:

template <class T>
swap(T& a, T& b) {
    T tmp(std::move(a));
    a = std::move(b);   
    b = std::move(tmp);
}

Pomyśl o tym, co się stanie, gdy Tpowiedzmy vector<int>rozmiar n. W pierwszej wersji czytasz i zapisujesz 3 * n elementów, w drugiej wersji w zasadzie odczytujesz i zapisujesz tylko 3 wskaźniki do buforów wektorów oraz rozmiary 3 buforów. Oczywiście klasa Tmusi wiedzieć, jak się poruszać; twoja klasa powinna mieć operator przypisania ruchu i konstruktor ruchu, aby klasa Tdziałała.

Możesz użyć move, gdy potrzebujesz „przenieść” zawartość obiektu w inne miejsce, bez robienia kopii (tzn. Treść nie jest powielana, dlatego może być używana na niektórych obiektach, których nie można skopiować, np. Unikatowa_ptr). Możliwe jest również, że obiekt pobierze zawartość obiektu tymczasowego bez robienia kopii (i oszczędza dużo czasu), przy pomocy std :: move.

Ten link naprawdę mi pomógł:

http://thbecker.net/articles/rvalue_references/section_01.html

Przepraszam, jeśli moja odpowiedź przychodzi za późno, ale szukałem również dobrego linku do std :: move, i znalazłem linki powyżej nieco „surowe”.

To kładzie nacisk na odniesienie do wartości r, w którym kontekście powinieneś ich użyć, i myślę, że jest bardziej szczegółowe, dlatego chciałem udostępnić ten link tutaj.

P: Co to jest std::move ?

ZA: std::move() jest funkcją z biblioteki standardowej C ++ do rzutowania na odwołanie do wartości.

Uproszczony std::move(t)jest równoważny z:

static_cast<T&&>(t);

Wartość jest wartością tymczasową, która nie utrzymuje się poza wyrażeniem, które ją definiuje, takim jak wynik funkcji pośredniej, który nigdy nie jest przechowywany w zmiennej.

int a = 3; // 3 is a rvalue, does not exist after expression is evaluated
int b = a; // a is a lvalue, keeps existing after expression is evaluated

Implementacja std :: move () jest podana w N2027: „Krótkie wprowadzenie do odwołań do wartości” w następujący sposób:

template <class T>
typename remove_reference<T>::type&&
std::move(T&& a)
{
    return a;
}

Jak widać, std::movezwraca T&&bez względu na to, czy zostanie wywołana z wartością ( T), typem referencji ( T&) czy wartością referencyjną wartości ( T&&).

P: Co to robi?

Odp .: Jako obsada nic nie robi podczas działania. Ważne jest tylko w czasie kompilacji, aby poinformować kompilator, że chcesz nadal traktować referencję jako wartość.

foo(3 * 5); // obviously, you are calling foo with a temporary (rvalue)

int a = 3 * 5;
foo(a);     // how to tell the compiler to treat `a` as an rvalue?
foo(std::move(a)); // will call `foo(int&& a)` rather than `foo(int a)` or `foo(int& a)`

Czego nie robi:

• Zrób kopię argumentu
• Wywołaj konstruktor kopiowania
• Zmień obiekt argumentu

P: Kiedy należy go używać?

Odp .: Powinieneś użyć, std::movejeśli chcesz wywoływać funkcje obsługujące semantykę przenoszenia z argumentem, który nie jest wartością (wyrażenie tymczasowe).

To rodzi dla mnie następujące pytania uzupełniające:

• Co to jest semantyka ruchu? Semantyka przenoszenia w przeciwieństwie do semantyki kopiowania jest techniką programowania, w której elementy obiektu są inicjowane przez „przejęcie” zamiast kopiowania elementów innego obiektu. Takie „przejmowanie” ma sens tylko w przypadku wskaźników i uchwytów zasobów, które można tanio przenosić, kopiując uchwyt wskaźnika lub liczby całkowitej zamiast bazowych danych.

• Jakie klasy i obiekty obsługują semantykę ruchów? Od programisty należy wdrożenie semantyki przenoszenia we własnych klasach, jeśli skorzystałoby z przeniesienia członków zamiast ich kopiowania. Po zaimplementowaniu semantyki przenoszenia bezpośrednio skorzystasz z pracy wielu programistów bibliotek, którzy dodali obsługę efektywnego zarządzania klasami z semantyką przenoszenia.

• Dlaczego kompilator nie może tego sam zrozumieć? Kompilator nie może po prostu wywołać kolejnego przeciążenia funkcji, chyba że tak powiesz. Musisz pomóc kompilatorowi wybrać, czy ma być wywoływana wersja zwykła czy przeniesiona funkcji.

• W jakich sytuacjach chciałbym powiedzieć kompilatorowi, że powinien traktować zmienną jak wartość? Najprawdopodobniej stanie się to w funkcjach szablonów lub bibliotek, gdzie wiesz, że można uzyskać wynik pośredni.

sam std :: move nie robi wiele. Myślałem, że wywołuje on konstruktor ruchu dla obiektu, ale tak naprawdę wykonuje rzut typu (rzutowanie zmiennej lvalue na wartość, aby wymieniona zmienna mogła zostać przekazana jako argument do konstruktora ruchu lub operatora przypisania).

Zatem std :: move jest po prostu używany jako prekursor do użycia semantyki move. Semantyka przesuwania jest zasadniczo skutecznym sposobem radzenia sobie z obiektami tymczasowymi.

Rozważ obiekt A = B + C + D + E + F;

To ładnie wyglądający kod, ale E + F tworzy obiekt tymczasowy. Następnie D + temp tworzy kolejny obiekt tymczasowy i tak dalej. W każdym normalnym operatorze „+” klasy występują głębokie kopie.

Na przykład

Object Object::operator+ (const Object& rhs) {
    Object temp (*this);
    // logic for adding
    return temp;
}

Utworzenie obiektu tymczasowego w tej funkcji jest bezużyteczne - te obiekty tymczasowe zostaną usunięte na końcu linii, gdy wyjdą poza zakres.

Możemy raczej użyć semantyki ruchu, aby „splądrować” obiekty tymczasowe i zrobić coś podobnego

 Object& Object::operator+ (Object&& rhs) {
     // logic to modify rhs directly
     return rhs;
 }

Pozwala to uniknąć niepotrzebnych głębokich kopii. W odniesieniu do przykładu jedyną częścią, w której zachodzi głębokie kopiowanie, jest teraz E + F. Reszta używa semantyki przenoszenia. Konstruktor ruchu lub operator przypisania również musi zostać zaimplementowany, aby przypisać wynik do A.

"Co to jest?" i „Co to robi?”zostało wyjaśnione powyżej.

Podam przykład „kiedy należy go użyć”.

Na przykład mamy klasę z dużą ilością zasobów, takich jak duża tablica.

class ResHeavy{ //  ResHeavy means heavy resource
    public:
        ResHeavy(int len=10):_upInt(new int[len]),_len(len){
            cout<<"default ctor"<<endl;
        }

        ResHeavy(const ResHeavy& rhs):_upInt(new int[rhs._len]),_len(rhs._len){
            cout<<"copy ctor"<<endl;
        }

        ResHeavy& operator=(const ResHeavy& rhs){
            _upInt.reset(new int[rhs._len]);
            _len = rhs._len;
            cout<<"operator= ctor"<<endl;
        }

        ResHeavy(ResHeavy&& rhs){
            _upInt = std::move(rhs._upInt);
            _len = rhs._len;
            rhs._len = 0;
            cout<<"move ctor"<<endl;
        }

    // check array valid
    bool is_up_valid(){
        return _upInt != nullptr;
    }

    private:
        std::unique_ptr<int[]> _upInt; // heavy array resource
        int _len; // length of int array
};

Kod testowy:

void test_std_move2(){
    ResHeavy rh; // only one int[]
    // operator rh

    // after some operator of rh, it becomes no-use
    // transform it to other object
    ResHeavy rh2 = std::move(rh); // rh becomes invalid

    // show rh, rh2 it valid
    if(rh.is_up_valid())
        cout<<"rh valid"<<endl;
    else
        cout<<"rh invalid"<<endl;

    if(rh2.is_up_valid())
        cout<<"rh2 valid"<<endl;
    else
        cout<<"rh2 invalid"<<endl;

    // new ResHeavy object, created by copy ctor
    ResHeavy rh3(rh2);  // two copy of int[]

    if(rh3.is_up_valid())
        cout<<"rh3 valid"<<endl;
    else
        cout<<"rh3 invalid"<<endl;
}

wyjście jak poniżej:

default ctor
move ctor
rh invalid
rh2 valid
copy ctor
rh3 valid

Możemy to zobaczyć za std::movepomocąmove constructor marki przekształcić zasób łatwo.

Gdzie jeszcze jest std::move przydaje?

std::movemoże być również przydatny podczas sortowania tablicy elementów. Wiele algorytmów sortowania (takich jak sortowanie selekcyjne i bąbelkowe) działa poprzez zamianę par elementów. Wcześniej musieliśmy używać semantyki kopiowania, aby wykonać wymianę. Teraz możemy użyć semantyki ruchu, która jest bardziej wydajna.

Może być również przydatny, jeśli chcemy przenieść zawartość zarządzaną przez jeden inteligentny wskaźnik do drugiego.

Cytowane:

• https://www.learncpp.com/cpp-tutorial/15-4-stdmove/

Oto pełny przykład użycia std :: move dla (prostego) niestandardowego wektora

Oczekiwany wynik:

 c: [10][11]
 copy ctor called
 copy of c: [10][11]
 move ctor called
 moved c: [10][11]

Kompiluj jako:

  g++ -std=c++2a -O2 -Wall -pedantic foo.cpp

Kod:

#include <iostream>
#include <algorithm>

template<class T> class MyVector {
private:
    T *data;
    size_t maxlen;
    size_t currlen;
public:
    MyVector<T> () : data (nullptr), maxlen(0), currlen(0) { }
    MyVector<T> (int maxlen) : data (new T [maxlen]), maxlen(maxlen), currlen(0) { }

    MyVector<T> (const MyVector& o) {
        std::cout << "copy ctor called" << std::endl;
        data = new T [o.maxlen];
        maxlen = o.maxlen;
        currlen = o.currlen;
        std::copy(o.data, o.data + o.maxlen, data);
    }

    MyVector<T> (const MyVector<T>&& o) {
        std::cout << "move ctor called" << std::endl;
        data = o.data;
        maxlen = o.maxlen;
        currlen = o.currlen;
    }

    void push_back (const T& i) {
        if (currlen >= maxlen) {
            maxlen *= 2;
            auto newdata = new T [maxlen];
            std::copy(data, data + currlen, newdata);
            if (data) {
                delete[] data;
            }
            data = newdata;
        }
        data[currlen++] = i;
    }

    friend std::ostream& operator<<(std::ostream &os, const MyVector<T>& o) {
        auto s = o.data;
        auto e = o.data + o.currlen;;
        while (s < e) {
            os << "[" << *s << "]";
            s++;
        }
        return os;
    }
};

int main() {
    auto c = new MyVector<int>(1);
    c->push_back(10);
    c->push_back(11);
    std::cout << "c: " << *c << std::endl;
    auto d = *c;
    std::cout << "copy of c: " << d << std::endl;
    auto e = std::move(*c);
    delete c;
    std::cout << "moved c: " << e << std::endl;
}