Prečo je potrebná sémantika presunu?

Semantika presunu v C++11 (a neskorších štandardoch) je potrebná na optimalizáciu výkonu prostredníctvom efektívneho využívania zdrojov.

Hlavné ciele:

• Vyhnutie sa vytváraniu dočasných kópií: Namiesto kopírovania dát objektov z dočasných premenných alebo rvalue odkazov, semantika presunu umožňuje "odovzdať" vlastníctvo zdrojov (napríklad pamäti na halde).
• Optimalizácia práce s kontajnermi a reťazcami: Operácie spojené so zmenou veľkosti kontajnerov (napríklad std::vector), alebo konkatenácia reťazcov, môžu byť výrazne zrýchlené pomocou presunu namiesto kopírovania.
• Podpora efektívnych konštruktorov presunu a operátorov priradenia presunom: Tieto špeciálne funkcie umožňujú objektom spravovať svoje zdroje pri presune.

Ako to funguje:

• lvalue a rvalue: V C++11 sa objavilo pojatie rvalue odkazov (&&), ktoré sa viažu na dočasné objekty alebo výrazy, ktorých výsledky nemajú trvalé miesto v pamäti.
• Konštruktor presunu (T::T(T&& other)) : Volá sa, keď je nový objekt inicializovaný rvalue odkazom. "Ukradne" zdroje od objektu other (napríklad prepisuje ukazovateľ na dáta), a potom nastaví other do bezpečného prázdneho stavu.
• Operátor priradenia presunom (T& T::operator=(T&& other)): Je podobný konštruktoru presunu, ale pre operácie priradenia.

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

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

public:
    // Konštruktor
    MyVector(size_t s) : size(s), data(new int[s]) {
        std::cout << "Konštruktor: alokácia pamäte" << std::endl;
    }

    // Deštruktor
    ~MyVector() {
        std::cout << "Deštruktor: uvoľnenie pamäte" << std::endl;
        delete[] data;
    }

    // Kopírovací konštruktor (pre porovnanie)
    MyVector(const MyVector& other) : size(other.size), data(new int[other.size]) {
        std::cout << "Kopírovací konštruktor: hlboké kopírovanie" << std::endl;
        std::copy(other.data, other.data + size, data);
    }

    // Presunový konštruktor
    MyVector(MyVector&& other) noexcept : size(other.size), data(other.data) {
        std::cout << "Presunový konštruktor: odovzdanie vlastníctva" << std::endl;
        // Resetovanie zdrojového objektu do bezpečného stavu
        other.data = nullptr;
        other.size = 0;
    }

    // Operátor priradenia kopírovaním (pre porovnanie)
    MyVector& operator=(const MyVector& other) {
        std::cout << "Operátor priradenia kopírovaním" << std::endl;
        if (this != &other) {
            delete[] data; // Uvoľnenie starých zdrojov
            size = other.size;
            data = new int[size];
            std::copy(other.data, other.data + size, data);
        }
        return *this;
    }

    // Operátor priradenia presunom
    MyVector& operator=(MyVector&& other) noexcept {
        std::cout << "Operátor priradenia presunom" << std::endl;
        if (this != &other) {
            delete[] data; // Uvoľnenie starých zdrojov
            size = other.size;
            data = other.data;
            // Resetovanie zdrojového objektu do bezpečného stavu
            other.data = nullptr;
            other.size = 0;
        }
        return *this;
    }
};

int main() {
    MyVector v1(10); // Volanie konštruktora

    // MyVector v2 = v1; // Volanie kopírovacieho konštruktora (pomalé)
    MyVector v2 = std::move(v1); // Volanie presunového konštruktora (rýchle)

    MyVector v3(5);
    //v3 = v2; // Volanie operátora priradenia kopírovaním (pomalé)
    v3 = std::move(v2); // Volanie operátora priradenia presunom (rýchle)

    // std::vector tiež používa semantiku presunu
    std::vector<int> vec1(1000000);
    std::vector<int> vec2 = std::move(vec1); // Žiadne kopírovanie všetkých prvkov

    return 0; // Volanie destruktorov
}

Výhody:

• Výkon: Výrazné zrýchlenie operácií spojených s odovzdávaním objektov s nákladnými zdrojmi.
• Efektívne využívanie pamäte: Vyhýba sa alokácii a uvoľneniu pamäte pre dočasné kópie.
• Podpora RAII: Umožňuje efektívne spravovať zdroje, aj pri presune objektov.

Semantika presunu je kľúčovou vlastnosťou C++11, ktorá výrazne zvyšuje efektívnosť práce s objektmi náročnými na zdroje.