Що таке std :: move (), і коли його слід використовувати?

1. Що це?
2. Що це робить?
3. Коли його слід використовувати?

Гарні посилання цінуються.

Сторінка Вікіпедії на C ++ 11 посилання на значення R та конструктори переміщення

1. У C ++ 11, крім копіюючих конструкторів, об’єкти можуть мати конструктори переміщення.
   (Окрім операторів копіювання, вони також мають операторів присвоєння переміщення.)
2. Конструктор переміщення використовується замість конструктора копіювання, якщо об’єкт має тип "rvalue-reference" ( Type &&).
3. std::move() являє собою команду, яка виробляє rvalue-посилання на об'єкт, щоб забезпечити рух від нього.

Це новий спосіб C ++, щоб уникнути копій. Наприклад, використовуючи конструктор переміщення, a std::vectorможе просто скопіювати свій внутрішній вказівник на дані на новий об’єкт, залишивши переміщений об’єкт у переміщеному стані, тому не копіюючи всіх даних. Це буде C ++ - дійсно.

Спробуйте googling для семантики переміщення, оцінок, ідеального переадресації.

1. "Що це?"

Хоча std::move() технічно це функція - я б сказав, що це насправді не функція . Це свого роду перетворювач між способами компілятор вважає значення виразу.

2. "Що це робить?"

Перше, що слід зазначити, це те, std::move() що насправді нічого не рухає . Він перетворює вираз із значення lvalue (наприклад, названої змінної) у xvalue . Значення xvalue повідомляє компілятору:

Ви можете пограбувати мене, перемістити все, що я тримаю, і використати його в іншому місці (оскільки я все одно незабаром буду знищений) ".

Іншими словами, коли ви використовуєте std::move(x), ви дозволяєте компілятору канібалізувати x. Таким чином, якщо x, скажімо, є власний буфер в пам'яті - після std::move()того, як компілятор може мати власний інший об'єкт.

_{Ви також можете перейти від першого значення (наприклад, тимчасового, коли ви проїжджаєте), але це рідко корисно.}

3. "Коли його слід використовувати?"

Ще один спосіб задати це питання: "Для чого я можу канібалізувати ресурси існуючого об'єкта?" добре, якщо ви пишете код програми, ви, ймовірно, не будете багато возитися з тимчасовими об'єктами, створеними компілятором. Тому в основному ви робите це в таких місцях, як конструктори, операторські методи, функції, подібні до стандартної бібліотеки та алгоритму тощо. Звичайно, це просто велике правило.

Типовим є «переміщення» ресурсів від одного об’єкта до іншого замість копіювання. @Guillaume посилається на цю сторінку, яка має простий короткий приклад: обмін двома об'єктами з меншим копіюванням.

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

використання переміщення дозволяє обмінюватися ресурсами, а не копіювати їх навколо:

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

Подумайте, що відбувається, коли T, скажімо, vector<int>розміру n. У першій версії ви читаєте і записуєте 3 * n елементів, у другій версії ви в основному читаєте і записуєте лише 3 вказівника до буферів векторів плюс 3 розміри буферів. Звичайно, класу Tпотрібно знати, як робити рухомий; ваш клас повинен мати оператора присвоєння переміщення та конструктора переміщення для класу, Tщоб це працювало.

Ви можете використовувати переміщення, коли вам потрібно "перенести" вміст об'єкта кудись інше, не роблячи копії (тобто вміст не дублюється, тому його можна використовувати на деяких не копіюваних об'єктах, наприклад, унікальний_ptr). Можливо також, що об’єкт може взяти вміст тимчасового об’єкта, не роблячи копії (і заощаджуючи багато часу), використовуючи std :: move.

Це посилання дійсно допомогло мені:

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

Вибачте, якщо моя відповідь надходить занадто пізно, але я також шукав хорошого посилання для std :: move, і я знайшов посилання вище трохи "суворими".

Це робить акцент на r-значення посилання, у якому контексті ви повинні їх використовувати, і я думаю, що це більш детально, тому я хотів поділитися цим посиланням тут.

З: Що таке std::move?

A: std::move()це функція зі стандартної бібліотеки C ++ для лиття на посилання rvalue.

Спрощено std::move(t)рівнозначно:

static_cast<T&&>(t);

Rvalue - це тимчасовий, який не зберігається поза виразом, який визначає його, наприклад, проміжний результат функції, який ніколи не зберігається у змінній.

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

Реалізація для std :: move () наведена в N2027: "Короткий вступ до посилання Rvalue" наступним чином:

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

Як бачите, std::moveповертаєтьсяT&& значення незалежно від того, якщо його викликають зі значенням ( T), типом посилання ( T&) або посиланням на rvalue ( T&&).

З: Що це робить?

Відповідь: Як акторський склад, він нічого не робить під час виконання. Доцільно лише в момент компіляції сказати компілятору, що ви хочете продовжувати розглядати посилання як оцінку.

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

Що це робить не робить:

• Зробіть копію аргументу
• Викличте конструктор копій
• Змініть об’єкт аргументу

Питання: Коли його слід використовувати?

A: Ви повинні використовувати std::move якщо ви хочете викликати функції, які підтримують семантику переміщення, аргументом, який не є rvalue (тимчасовим виразом).

Це вимагає наступних питань для мене:

• Що таке семантика руху? Переміщення семантики на відміну від семантики копіювання - це метод програмування, в якому члени об'єкта ініціалізуються шляхом «переймання» замість копіювання членів іншого об’єкта. Таке "перехоплення" має сенс лише вказівниками та ручками ресурсів, які можна дешево перенести, скопіювавши вказівник або цілу ручку, а не базові дані.

• Які класи та об'єкти підтримують семантику переміщення? Ви, як розробник, вирішувати впроваджувати семантику переміщення у своїх власних класах, якщо вони отримають користь від передачі своїх членів, а не копіювання. Після того як ви реалізуєте семантику переміщення, ви отримаєте безпосередню користь від роботи багатьох програмістів бібліотеки, які додали підтримку для ефективного керування класами з семантикою переміщення.

• Чому компілятор не може зрозуміти це самостійно? Компілятор не може просто викликати чергове перевантаження функції, якщо ви цього не скажете. Ви повинні допомогти компілятору вибрати вибір, чи слід викликати звичайну або переміщувану версію функції.

• У яких ситуаціях я хотів би сказати компілятору, що він повинен ставитися до змінної як до rvalue? Найімовірніше, це відбудеться в функціях шаблону або бібліотеки, де ви знаєте, що проміжний результат може бути виправлений

std :: сам переміщення насправді не дуже багато. Я подумав, що він називає переміщений конструктор для об'єкта, але він справді просто виконує передачу типу (кидає змінну lvalue в rvalue, щоб згадана змінна могла бути передана як аргумент конструктору переміщення або оператору призначення).

Отже, std :: move просто використовується як попередник використання семантики переміщення. Семантика переміщення - це, по суті, ефективний спосіб поводження з тимчасовими об'єктами.

Розглянемо об’єкт A = B + C + D + E + F;

Це добре виглядає код, але E + F створює тимчасовий об'єкт. Тоді D + temp виробляє ще один тимчасовий об'єкт тощо. У кожному звичайному "+" операторі класу трапляються глибокі копії.

Наприклад

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

Створення тимчасового об’єкта в цій функції марно - ці тимчасові об'єкти все одно будуть видалені в кінці рядка, коли вони вийдуть за межі області.

Ми можемо скоріше використовувати семантику переміщення, щоб "грабувати" тимчасові об'єкти і робити щось подібне

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

Це дозволяє уникнути зайвих глибоких копій. Посилаючись на приклад, єдиною частиною, де відбувається глибоке копіювання, є тепер E + F. Решта використовує семантику переміщення. Конструктор переміщення або оператор призначення також повинен бути реалізований для присвоєння результату А.

"Що це?" і "Що це робить?" було пояснено вище.

Наведу приклад "коли це слід використовувати".

Наприклад, у нас є клас з великою кількістю ресурсів, таких як великий масив.

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

Код тесту:

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

вихід, як показано нижче:

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

Ми можемо бачити, що std::moveз допомогою move constructorперетворення ресурсу легко.

Де ще std::moveкорисно?

std::moveтакож може бути корисним при сортуванні масиву елементів. Багато алгоритмів сортування (наприклад, сортування сортування та сортування міхурів) працюють шляхом заміни пар елементів. Раніше нам довелося вдатися до копіювання-семантики, щоб зробити своп. Тепер ми можемо використовувати семантику переміщення, яка є більш ефективною.

Це також може бути корисно, якщо ми хочемо перемістити вміст, керований одним розумним вказівником, на інший.

Цитується:

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

Ось повний приклад, використовуючи std :: move для (простого) користувацького вектора

Очікуваний вихід:

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

Складіть як:

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

Код:

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