Miért szükséges a mozgás szemantikája?

A move-értelmezés a C++11-ben (és későbbi szabványokban) szükséges a teljesítmény optimalizálásához az erőforrások hatékony kihasználásával.

Fő célok:

• Ideiglenes másolatok létrehozásának elkerülése: Ahelyett, hogy az adatok másolódnának ideiglenes változókból vagy rvalue hivatkozásokból, a move-értelmezés lehetővé teszi az erőforrások (pl. heap memória) tulajdonjogának átruházását.
• A tárolók és stringek kezelésének optimalizálása: Az olyan műveletek, amelyek a tárolók méretének változtatásával vagy stringek összefűzésével kapcsolatosak, jelentősen gyorsíthatók move-vel, nem másolással.
• Hatékony move-constructors és move-assign operátorok támogatása: Ezek a speciális tagfüggvények lehetővé teszik az objektumok számára, hogy hatékonyan kezeljék erőforrásaikat a move során.

Hogyan működik:

• lvalue és rvalue: A C++11-ben bevezették az rvalue-referenciák (&&) fogalmát, amelyek ideiglenes objektumokhoz vagy olyan kifejezésekhez kapcsolódnak, amelyek eredményei nem rendelkeznek állandó memóriahelytel.
• Move-constructors (T::T(T&& other)): Akkor hívódik meg, amikor egy új objektum rvalue-referenciával van inicializálva. "Elrabolja" az other erőforrásait (pl. mutató átállítása az adatokra), majd other-t biztonságos, üres állapotba állítja.
• Move-assign operátor (T& T::operator=(T&& other)): Hasonló a move-constructhoz, de az értékadás műveleteire.

#include <vector>
#include <iostream>
#include <utility> // std::move-hoz

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

public:
    // Konstruktor
    MyVector(size_t s) : size(s), data(new int[s]) {
        std::cout << "Konstruktor: memória foglalás" << std::endl;
    }

    // Destruktor
    ~MyVector() {
        std::cout << "Destruktor: memória felszabadítás" << std::endl;
        delete[] data;
    }

    // Move-constructors
    MyVector(MyVector&& other) noexcept : size(other.size), data(other.data) {
        std::cout << "Move-constructors: tulajdonjog átruházása" << std::endl;
        other.data = nullptr;
        other.size = 0;
    }

    // Move-assign operátor
    MyVector& operator=(MyVector&& other) noexcept {
        std::cout << "Move-assign operátor" << 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); // Konstruktor hívás
    MyVector v2 = std::move(v1); // Move-constructors hívás
    MyVector v3(5);
    v3 = std::move(v2); // Move-assign operátor hívás
    return 0;
}

Előnyök:

• Teljesítmény: Jelentős gyorsulás a költséges erőforrásokat tartalmazó objektumok átvitelében.
• Hatékony memóriahasználat: Elkerüli a temporális másolatokhoz való memóriafoglalást és felszabadítást.
• RAII támogatás: Hatékony erőforrás-kezelést tesz lehetővé, még az objektumok move során is.

A move-értelmezés egy kulcsfontosságú jellemzője a C++11-nek, amely jelentősen növeli az erőforrás-igényes objektumok hatékonyságát.