Che cos'è std :: move () e quando dovrebbe essere usato?

1. Che cos'è?
2. Che cosa fa?
3. Quando dovrebbe essere usato?

I buoni collegamenti sono apprezzati.

Pagina di Wikipedia su riferimenti di valore R in C ++ 11 e costruttori di spostamento

1. In C ++ 11, oltre ai costruttori di copie, gli oggetti possono avere costruttori di spostamento.
   (E oltre a copiare gli operatori di assegnazione, hanno operatori di assegnazione di spostamenti.)
2. Il costruttore di spostamento viene utilizzato al posto del costruttore di copia, se l'oggetto ha il tipo "rvalue-reference" ( Type &&).
3. std::move() è un cast che produce un riferimento al valore a un oggetto, per consentire lo spostamento da esso.

È un nuovo modo C ++ per evitare copie. Ad esempio, usando un costruttore di spostamento, a std::vectorpotrebbe semplicemente copiare il suo puntatore interno ai dati nel nuovo oggetto, lasciando l'oggetto spostato in uno stato spostato dallo stato, quindi non copiare tutti i dati. Questo sarebbe C ++ - valido.

Prova a cercare su Google la semantica dei movimenti, il valore, l'inoltro perfetto.

1. "Che cos'è?"

Anche std::move() se tecnicamente è una funzione, direi che non è davvero una funzione . È una specie di convertitore tra i modi in cui il compilatore considera il valore di un'espressione.

2. "Che cosa fa?"

La prima cosa da notare è che in std::move() realtà non sposta nulla . Converte un'espressione da essere un valore (come una variabile denominata) in un valore x . Un xvalue dice al compilatore:

Puoi saccheggiarmi, spostare tutto ciò che tengo in mano e usarlo altrove (dato che comunque sarò distrutto presto) ".

in altre parole, quando usi std::move(x), stai permettendo al compilatore di cannibalizzare x. Quindi, se xha, diciamo, il suo buffer in memoria - dopo std::move()ing il compilatore può avere un altro oggetto al suo posto.

_{Puoi anche spostarti da un valore (come un temporaneo che stai passando), ma questo è raramente utile.}

3. "Quando dovrebbe essere usato?"

Un altro modo di porre questa domanda è "Per cosa dovrei cannibalizzare le risorse di un oggetto esistente?" bene, se stai scrivendo il codice dell'applicazione, probabilmente non ti sbaglierebbe molto con gli oggetti temporanei creati dal compilatore. Quindi principalmente lo faresti in luoghi come costruttori, metodi di operatore, funzioni simili a algoritmi di libreria standard ecc. In cui gli oggetti vengono creati e distrutti molto automagicamente. Certo, questa è solo una regola empirica.

Un uso tipico è lo "spostamento" delle risorse da un oggetto a un altro anziché la copia. @Guillaume collega a questa pagina che ha un breve esempio semplice: scambiare due oggetti con meno copie.

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

l'utilizzo di move ti consente di scambiare le risorse invece di copiarle:

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

Pensa a cosa succede quando T, diciamo, vector<int>della taglia n. Nella prima versione leggi e scrivi elementi 3 * n, nella seconda versione fondamentalmente leggi e scrivi solo i 3 puntatori ai buffer dei vettori, più le dimensioni dei 3 buffer. Naturalmente, la classe Tdeve sapere come muoversi; la tua classe dovrebbe avere un operatore di assegnazione di mosse e un costruttore di mosse affinché la classe Tfunzioni.

Puoi usare move quando devi "trasferire" il contenuto di un oggetto da qualche altra parte, senza fare una copia (cioè il contenuto non è duplicato, ecco perché potrebbe essere usato su alcuni oggetti non copiabili, come un unique_ptr). È anche possibile che un oggetto prenda il contenuto di un oggetto temporaneo senza fare una copia (e risparmiare molto tempo), con std :: move.

Questo link mi ha davvero aiutato:

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

Mi dispiace se la mia risposta arriva troppo tardi, ma stavo anche cercando un buon link per lo std :: move, e ho trovato i link sopra un po '"austeri".

Questo pone l'accento sul riferimento al valore r, in quale contesto dovresti usarli, e penso che sia più dettagliato, ecco perché volevo condividere questo link qui.

D: Cos'è std::move?

A: std::move()è una funzione della libreria standard C ++ per il cast in un riferimento di valore.

Semplicemente std::move(t)equivale a:

static_cast<T&&>(t);

Un valore è un valore temporaneo che non persiste oltre l'espressione che lo definisce, come un risultato di funzione intermedia che non viene mai memorizzato in una variabile.

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

Un'implementazione per std :: move () è data in N2027: "Una breve introduzione ai riferimenti di valore" come segue:

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

Come puoi vedere, std::moverestituisce T&&non importa se chiamato con un valore ( T), un tipo di riferimento ( T&) o un riferimento rvalue ( T&&).

Q: che cosa fa?

A: Come cast, non fa nulla durante il runtime. È rilevante solo al momento della compilazione per dire al compilatore che si desidera continuare a considerare il riferimento come un valore.

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)`

Cosa non fa:

• Fai una copia dell'argomento
• Chiama il costruttore di copie
• Cambia l'oggetto argomento

Q: Quando dovrebbe essere usato?

A: Dovresti usare std::movese vuoi chiamare funzioni che supportano la semantica di movimento con un argomento che non è un valore (espressione temporanea).

Questo mi pone le seguenti domande di follow-up:

• Cosa sono le semantiche di movimento? Spostare la semantica in contrasto con la copia della semantica è una tecnica di programmazione in cui i membri di un oggetto vengono inizializzati "prendendo il posto" invece di copiare i membri di un altro oggetto. Tale "presa in consegna" ha senso solo con i puntatori e gli handle delle risorse, che possono essere trasferiti a buon mercato copiando il puntatore o l'handle intero anziché i dati sottostanti.

• Che tipo di classi e oggetti supportano la semantica di movimento? Spetta a te come sviluppatore implementare la semantica di movimento nelle tue classi se questi trarrebbero beneficio dal trasferimento dei loro membri invece di copiarli. Una volta implementata la semantica di spostamento, beneficerai direttamente del lavoro di molti programmatori di biblioteche che hanno aggiunto il supporto per la gestione efficiente delle classi con la semantica di spostamento.

• Perché il compilatore non riesce a capirlo da solo? Il compilatore non può semplicemente chiamare un altro sovraccarico di una funzione se non lo dici tu. È necessario aiutare il compilatore a scegliere se chiamare la versione normale o sposta della funzione.

• In quali situazioni vorrei dire al compilatore che dovrebbe trattare una variabile come un valore? Ciò accadrà molto probabilmente nelle funzioni di template o libreria, dove sai che un risultato intermedio potrebbe essere salvato.

std :: move in sé non fa molto. Ho pensato che chiamasse il costruttore spostato per un oggetto, ma in realtà esegue semplicemente un cast di tipo (lanciando una variabile lvalue su un valore in modo che la suddetta variabile possa essere passata come argomento a un costruttore di spostamento o operatore di assegnazione).

Quindi std :: move è appena usato come precursore nell'uso della semantica di movimento. Spostare la semantica è essenzialmente un modo efficiente per gestire oggetti temporanei.

Prendi in considerazione l'oggetto A = B + C + D + E + F;

Questo è un bel codice, ma E + F produce un oggetto temporaneo. Quindi D + temp produce un altro oggetto temporaneo e così via. In ogni normale operatore "+" di una classe, si verificano copie profonde.

Per esempio

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

La creazione dell'oggetto temporaneo in questa funzione è inutile: questi oggetti temporanei verranno comunque eliminati alla fine della riga quando escono dall'ambito.

Possiamo piuttosto usare la semantica di movimento per "saccheggiare" gli oggetti temporanei e fare qualcosa di simile

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

Questo evita che vengano fatte copie profonde inutili. Con riferimento all'esempio, l'unica parte in cui si verifica la copia in profondità è ora E + F. Il resto utilizza la semantica di spostamento. Anche il costruttore di movimenti o l'operatore di assegnazione deve essere implementato per assegnare il risultato ad A.

"Che cos'è?" e "che cosa fa?" è stato spiegato sopra.

Darò un esempio di "quando dovrebbe essere usato".

Ad esempio, abbiamo una classe con molte risorse come un grande array.

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

Codice di prova:

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

uscita come di seguito:

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

Possiamo vedere che std::movecon move constructorrende facilmente trasformare le risorse.

Dove altro è std::moveutile?

std::movepuò anche essere utile durante l'ordinamento di una matrice di elementi. Molti algoritmi di ordinamento (come ordinamento per selezione e ordinamento a bolle) funzionano scambiando coppie di elementi. In precedenza, abbiamo dovuto ricorrere alla copia-semantica per eseguire lo scambio. Ora possiamo usare la semantica di movimento, che è più efficiente.

Può anche essere utile se vogliamo spostare i contenuti gestiti da un puntatore intelligente a un altro.

Citato:

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

Ecco un esempio completo, usando std :: move per un vettore (semplice) personalizzato

Uscita prevista:

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

Compila come:

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

Codice:

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