Mit tud az okos mutatókról C++-ban?

Intelligens mutatók - RAII-körülöttek a szokásos (nyers) mutatók felett C++-ban, amelyek automatikusan kezelik a lefoglalt memória életciklusát, megelőzve a memória szivárgását.

A C++ szabványkönyvtár fő típusai:

• std::unique_ptr
• std::shared_ptr
• std::weak_ptr

std::unique_ptr

• Exkluzív erőforrás-kezeli.
• Nem másolható, de mozgatható.
• Egy erőforrás egyedi tulajdonlására használják.
• Minimális overhead, megegyezik a nyers mutatóval.

// unique_ptr példa
#include <memory>
#include <iostream>

int main() {
    std::unique_ptr<int> ptr = std::make_unique<int>(10);
    std::cout << *ptr << std::endl; // 10
    // std::unique_ptr<int> ptr2 = ptr; // Fordítási hiba: az unique_ptr nem másolható
    std::unique_ptr<int> ptr3 = std::move(ptr); // Tulajdonjog áthelyezése
    std::cout << *ptr3 << std::endl; // 10
    // std::cout << *ptr << std::endl; // Undefined behavior: ptr most üres
    return 0;
}

std::shared_ptr

• Több mutató közösen birtokolhat egy erőforrást.
• Hivatkozásszámlálót használ. A memória felszabadul, amikor a számláló eléri a nullát.
• Másolható. Minden másolat növeli a hivatkozásszámot.
• Magasabb overhead, mint az unique_ptr, a számláló kezelés miatt.

// shared_ptr példa
#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> ptr1 = std::make_shared<int>(20);
    std::cout << *ptr1 << " (use_count: " << ptr1.use_count() << ")" << std::endl; // 20 (use_count: 1)
    std::shared_ptr<int> ptr2 = ptr1; // Másolás, növeli a use_count értékét
    std::cout << *ptr1 << " (use_count: " << ptr1.use_count() << ")" << std::endl; // 20 (use_count: 2)
    std::shared_ptr<int> ptr3 = ptr1; // Még egy másolat
    std::cout << *ptr1 << " (use_count: " << ptr1.use_count() << ")" << std::endl; // 20 (use_count: 3)
    return 0;
}

std::weak_ptr

• Nem birtokol erőforrást, és nem növeli a hivatkozásszámot.
• A shared_ptr közötti ciklikus hivatkozások problémájának megoldására használják.
• Hozzáférést tesz lehetővé az erőforráshoz, amit a shared_ptr mutat, de nem akadályozza annak törlését.
• Az erőforráshoz való hozzáféréshez a weak_ptr-t shared_ptr-vé kell alakítani a lock() metódussal.

// weak_ptr példa
#include <memory>
#include <iostream>

int main() {
    std::shared_ptr<int> shared_ptr_int = std::make_shared<int>(30);
    std::weak_ptr<int> weak_ptr_int = shared_ptr_int;

    if (auto locked_ptr = weak_ptr_int.lock()) {
        std::cout << *locked_ptr << std::endl; // 30
    } else {
        std::cout << "A erőforrás már törölve lett." << std::endl;
    }

    shared_ptr_int.reset(); // Az erőforrás felszabadul

    if (auto locked_ptr = weak_ptr_int.lock()) {
        std::cout << *locked_ptr << std::endl;
    } else {
        std::cout << "A erőforrás már törölve lett." << std::endl; // Az erőforrás már törölve
    }
    return 0;
}

A modern C++-ban az intelligens mutatók használata jó gyakorlat, mivel jelentősen csökkenti a memória kezelés hibáinak valószínűségét.