Что такое std:: move () и когда его следует использовать?

вы можете использовать move, когда вам нужно "перенести" содержимое объекта в другое место, не делая копию (e.G содержимое не дублируется, поэтому его можно использовать для некоторых непопираемых объектов, таких как unique_ptr). Кроме того, объект может взять содержимое временного объекта без копирования (и сэкономить много времени) с помощью std::move.

эта ссылка действительно помогла мне :

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

извините, если мой ответ приходит слишком поздно, но я также искал хорошую ссылку для std::move, и я нашел ссылки выше немного "строгие".

Это делает акцент на R-value reference, в каком контексте вы должны их использовать, и я думаю, что это более подробно, поэтому я хотел поделиться этой ссылкой здесь.

1. "Что это?"

пока std::move() технически является функцией-я бы сказал это не действительно функция. Это своего рода конвертер между способами компилятор учитывает значение выражения.

2. "Что он делает?"

первое, что следует отметить, это std::move() не все.

_{если вы когда-нибудь смотрели мультсериал отбеливатель - он делает эквивалент Куинси Seele Schneider ' s Рейши размягчения.}

серьезно, однако, он преобразует выражение из lvalue или pure rvalue (например, переменная, которую вы можете использовать в течение длительного времени, или временная, которую вы передаете на некоторое время, соответственно), чтобы быть xvalue. Xvalue сообщает компилятору:

можно грабить я,движение все, что я держу и использую в другом месте (так как я все равно скоро буду уничтожен)".

другими словами, когда вы используете std::move(x), вы позволяете компилятору раскулачить x. Таким образом, если x есть, скажем, свой собственный буфер в памяти - после std::move()ing компилятор может иметь другой объект, владеющий им.

3. "Когда его следует использовать?"

другой способ задать этот вопрос: "Что бы я использовать/раскулачить в ресурсы объекта для?"ну, если вы пишете код приложения, вы, вероятно, не будете много возиться с временными объектами, созданными компилятором. Поэтому в основном вы будете делать это в таких местах, как конструкторы, методы операторов, STL-алгоритмические функции и т. д. где объекты создаются и уничтожаются автоматически много. Конечно, это просто правило.

типичным использованием является "перемещение" ресурсов из одного объекта в другой вместо копирования. @Гийом ссылки на на этой странице который имеет простой короткий пример: замена двух объектов с меньшим копированием.

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

использование move позволяет поменять местами ресурсы вместо копирования их вокруг:

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 указателя на буферы векторов. Конечно, класс T должен знать, как это сделать перемещение; у вас должен быть оператор назначения перемещения и конструктор перемещения для класса T, чтобы это работало.

Q: Что такое 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&&).

Q: что он делает?

A: в качестве приведения он ничего не делает во время выполнения. Важно только во время компиляции сообщить компилятору, что вы хотели бы продолжить рассмотрение ссылки как значение rvalue.

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

что это значит не do:

• сделайте копию аргумента
• вызовите конструктор копирования
• изменить объект аргумента

Q: когда он должен быть использован?

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

это требует следующего последующие вопросы для меня:

• что такое семантика перемещения? Семантика перемещения в отличие от семантики копирования-это метод программирования, в котором члены объекта инициализируются путем "захвата" вместо копирования членов другого объекта. Такой "захват" имеет смысл только с указателями и дескрипторами ресурсов, которые могут быть дешево переданы путем копирования указателя или целочисленного дескриптора, а не базовых данных.

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

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

• в каких ситуациях я хотел бы сказать компилятору, что он должен рассматривать переменную как rvalue? Это, скорее всего, произойдет в функциях шаблона или библиотеки, где вы знаете, что промежуточный результат может быть спасен.

std:: move сам по себе не очень много делает. Я думал, что он вызвал перемещенный конструктор для объекта, но на самом деле он просто выполняет приведение типа (приведение переменной 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. остальное использует семантику перемещения. Конструктор перемещения или оператор присваивания также должны быть реализованы, чтобы назначить результат A.

What is it? и What does it do? было объяснено выше.

я приведу пример when it should be used.

например, у нас есть класс с большим количеством ресурсов, таких как большой массив.

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/