De ce este nevoie de semantică pentru deplasare…

Semantica mutării în C++11 (și standardele ulterioare) este necesară pentru optimizarea performanței prin utilizarea eficientă a resurselor.

Obiective principale:

Evitarea creării de copii temporare: În loc să copieze datele obiectelor din variabile temporare sau referințe rvalue, semantica mutării permite "transferul" de proprietate asupra resurselor (de exemplu, memoria heap).
Optimizarea lucrului cu containere și șiruri: Operațiile legate de schimbarea dimensiunii containerelor (de exemplu, std::vector) sau concatenarea șirurilor pot fi accelerate semnificativ prin mutare, nu copiere.
Sprijin pentru constructorii de mutare și operatorii de atribuire prin mutare eficienți: Aceste funcții membre specializate permit obiectelor să gestioneze resursele în timpul mutării.

Cum funcționează:

lvalue și rvalue: În C++11 a fost introdus conceptul de referințe rvalue (&&), care se leagă de obiecte temporare sau expresii ale căror rezultate nu au o locație fixă în memorie.
Constructorul de mutare (T::T(T&& other)): Este apelat atunci când un nou obiect este inițializat cu o referință rvalue. Acesta "fură" resursele obiectului other (de exemplu, redirecționează pointerul către date), apoi setează other într-o stare sigură și goală.
Operatorul de atribuire prin mutare (T& T::operator=(T&& other)): Este similar cu constructorul de mutare, dar pentru operații de atribuire.

#include <vector>
#include <iostream>
#include <utility> // Pentru std::move

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

public:
    // Constructor
    MyVector(size_t s) : size(s), data(new int[s]) {
        std::cout << "Constructor: alocare memorie" << std::endl;
    }

    // Destructor
    ~MyVector() {
        std::cout << "Destructor: eliberare memorie" << std::endl;
        delete[] data;
    }

    // Constructor de copiere (pentru comparație)
    MyVector(const MyVector& other) : size(other.size), data(new int[other.size]) {
        std::cout << "Constructor de copiere: copiere profundă" << std::endl;
        std::copy(other.data, other.data + size, data);
    }

    // Constructor de mutare
    MyVector(MyVector&& other) noexcept : size(other.size), data(other.data) {
        std::cout << "Constructor de mutare: transfer de proprietate" << std::endl;
        // Resetarea obiectului sursă în stare sigură
        other.data = nullptr;
        other.size = 0;
    }

    // Operator de atribuire prin copiere (pentru comparație)
    MyVector& operator=(const MyVector& other) {
        std::cout << "Operator de atribuire prin copiere" << std::endl;
        if (this != &other) {
            delete[] data; // Eliberare resurse vechi
            size = other.size;
            data = new int[size];
            std::copy(other.data, other.data + size, data);
        }
        return *this;
    }

    // Operator de atribuire prin mutare
    MyVector& operator=(MyVector&& other) noexcept {
        std::cout << "Operator de atribuire prin mutare" << std::endl;
        if (this != &other) {
            delete[] data; // Eliberare resurse vechi
            size = other.size;
            data = other.data;
            // Resetarea obiectului sursă
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
};

int main() {
    MyVector v1(10); // Apel constructor

    // MyVector v2 = v1; // Apel constructor de copiere (lent)
    MyVector v2 = std::move(v1); // Apel constructor de mutare (rapid)

    MyVector v3(5);
    //v3 = v2; // Apel operator de atribuire prin copiere (lent)
    v3 = std::move(v2); // Apel operator de atribuire prin mutare (rapid)

    // std::vector folosește, de asemenea, semantica mutării
    std::vector<int> vec1(1000000);
    std::vector<int> vec2 = std::move(vec1); // Fără copierea tuturor elementelor

    return 0; // Apel destructor
}

Beneficii:

Performanță: Accelerare semnificativă a operațiilor de transfer al obiectelor cu resurse costisitoare.
Utilizare eficientă a memoriei: Se evită alocarea și eliberarea memoriei pentru copii temporare.
Suport pentru RAII: Permite gestionarea eficientă a resurselor, chiar și în cazul mutării obiectelor.

Semantica mutării este o caracteristică cheie a C++11, care crește semnificativ eficiența manipulării obiectelor cu resurse.

De ce este nevoie de semantică pentru deplasare?