Ինչու է անհրաժեշտ շարժման սեմանտիկան?

Սեմանտիկա տեղափոխման C++11-ում (և հետագա ստանդարտներում) անհրաժեշտ է արդյունավետ օգտագործելու համար ռեսուրսները՝ կատարողականությունը բարելավելու համար:

Հիմնական նպատակները:

• Անցնել ժամանակավոր կոպիաները: Փոխարենը տվյալների կոպիան ժամանակավոր փոփոխականներից կամ rvalue-հղումներից, սեմանտիկա տեղափոխման թույլ է տալիս "փոխանցել" ռեսուրսների սեփականությունը (օրինակ, heap-ի հիշողությունը):
• Կոնտեյներների և տեքստերի աշխատանքի օպտիմալացում: Օպերացիաները, որոնք կապված են կոնտեյներների չափի փոփոխության կամ տեքստերի կոնկատենացիայի հետ, կարող են զգալիորեն արագացվել տեղափոխման միջոցով, ոչ թե կոպիայի:
• Աջակցություն արդյունավետ տեղափոխման կոնստրուկտորների և վերագրումների օպերատորների: Այս հատուկ ֆունկցիաները թույլ են տալիս օբյեկտներին կառավարել իրենց ռեսուրսները տեղափոխման ժամանակ:

Ինչպես է դա աշխատում:

• lvalue և rvalue: C++11-ում հայտնվեց rvalue-հղումների հասկացությունը (&&), որոնք կապված են ժամանակավոր օբյեկտների կամ արտահայտությունների հետ, որոնց արդյունքները չեն ունենա մշտական տեղ հիշողության մեջ:
• Տեղափոխման կոնստրուկտոր (T::T(T&& other)): Կոչվում է, երբ նոր օբյեկտը ինիցիալիզացվում է rvalue-հղումով: Նա "թափում" ռեսուրսները other օբյեկտից (օրինակ, փոխում է ցուցիչը տվյալների վրա), և հետո other-ին տալիս է անվտանգ դատարկ վիճակ:
• Տեղափոխման վերագրում օպերատոր (T& T::operator=(T&& other)): Դրա նման է տեղափոխման կոնստրուկտորին, բայց վերագրումների համար:

#include <vector>
#include <iostream>
#include <utility> // std::move-ի համար

class MyVector {
private:
    int* data;
    size_t size;

public:
    // Կոնստրուկտոր
    MyVector(size_t s) : size(s), data(new int[s]) {
        std::cout << "Կոնստրուկտոր: հիշողության հատկացում" << std::endl;
    }

    // Դեաստրուկտոր
    ~MyVector() {
        std::cout << "Դեաստրուկտոր: հիշողության ազատում" << std::endl;
        delete[] data;
    }

    // Կոպի կոնստրուկտոր (համեմատության համար)
    MyVector(const MyVector& other) : size(other.size), data(new int[other.size]) {
        std::cout << "Կոպի կոնստրուկտոր: խորքային կոպիա" << std::endl;
        std::copy(other.data, other.data + size, data);
    }

    // Տեղափոխման կոնստրուկտոր
    MyVector(MyVector&& other) noexcept : size(other.size), data(other.data) {
        std::cout << "Տեղափոխման կոնստրուկտոր: սեփականության փոխանցում" << std::endl;
        other.data = nullptr;
        other.size = 0;
    }

    // Կոպի վերագրում (համեմատության համար)
    MyVector& operator=(const MyVector& other) {
        std::cout << "Կոպի վերագրում" << std::endl;
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = new int[size];
            std::copy(other.data, other.data + size, data);
        }
        return *this;
    }

    // Տեղափոխման վերագրում
    MyVector& operator=(MyVector&& other) noexcept {
        std::cout << "Տեղափոխման վերագրում" << std::endl;
        if (this != &other) {
            delete[] data;
            size = other.size;
            data = other.data;
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
};

int main() {
    MyVector v1(10); // Կոչվում է կոնստրուկտորը
    // MyVector v2 = v1; // Կոչվում է կոպի կոնստրուկտորը (դանդաղ)
    MyVector v2 = std::move(v1); // Կոչվում է տեղափոխման կոնստրուկտորը (արագ)
    MyVector v3(5);
    //v3 = v2; // Կոչվում է վերագրում կոպի միջոցով (դանդաղ)
    v3 = std::move(v2); // Կոչվում է վերագրում տեղափոխման միջոցով (արագ)
    // std::vector-ը նույնպես օգտագործում է տեղափոխման սեմանտիկա
    std::vector<int> vec1(1000000);
    std::vector<int> vec2 = std::move(vec1); // Չի կատարվում բոլոր տարրերի կոպիան
    return 0; // Կոչվում են դեաստրուկտորները
}

Առավելություններ:

• Աշխատունակություն: Արժեքային արագացում ծանր ռեսուրսներ պահանջող օբյեկտների փոխանցման ժամանակ:
• Հիշողության արդյունավետ օգտագործում: Չի կատարվում ժամանակավոր կոպիաների համար հիշողության հատկացում և ազատում:
• RAII-ի աջակցություն: Մեկնարկել է ռեսուրսների արդյունավետ կառավարում, նույնիսկ օբյեկտների տեղափոխման ժամանակ:

Սեմանտիկա տեղափոխմանն է հիմնական հատկանիշը C++11-ում, որը զգալիորեն բարձրացնում է ռեսուրսներ պահանջող օբյեկտների արդյունավետությունը։