std::dynamic pointer cast

std::dynamic pointer cast (tsz. std::dynamic pointer casts)

1. (informatika) A std::dynamic_pointer_cast a C++ Standard Library egyik fontos eszköze az okos pointerek (smart pointers), azon belül is a std::shared_ptr típus biztonságos futásidejű típuskonverziójára. Olyan típuskonverzióra használjuk, ahol az öröklődési hierarchia miatt szükség lehet dinamikus castolásra — például amikor egy Base osztályra mutató shared_ptr-t szeretnénk Derived osztályra mutató shared_ptr-ré alakítani.

std::shared_ptr<Derived> ptr2 = std::dynamic_pointer_cast<Derived>(ptr1);

• ptr1 egy std::shared_ptr<Base> típusú pointer.
• A Base osztálynak virtuális destruktora kell, hogy legyen, különben a dynamic_cast nem fog működni helyesen.

A std::dynamic_pointer_cast a dynamic_cast C++ kulcsszóra épül, és csak akkor működik, ha a típusok között valóban van érvényes, biztonságos downcast (pl. Base* → Derived*).

Ha a cast nem sikeres (pl. a Base objektum valójában nem Derived típusú), akkor az eredmény egy üres (nullptr) shared_ptr.

• Virtuális függvények szükségesek a bázisosztályban: a dynamic_cast csak akkor működik, ha az osztály polimorf (legalább egy virtuális metódusa van).
• Csak std::shared_ptr-rel működik (nem működik unique_ptr-rel, arra static_cast-al egyedi sablonmegoldást kell írni).

#include <iostream>
#include <memory>

class Base {
public:
    virtual ~Base() = default;
};

class Derived : public Base {
public:
    void hello() {
        std::cout << "Hello from Derived\n";
    }
};

int main() {
    std::shared_ptr<Base> basePtr = std::make_shared<Derived>();

    std::shared_ptr<Derived> derivedPtr = std::dynamic_pointer_cast<Derived>(basePtr);
    if (derivedPtr) {
        derivedPtr->hello();  // Sikeres cast, hívható a Derived metódusa
    } else {
        std::cout << "Cast failed\n";
    }

    // Sikertelen példa
    std::shared_ptr<Base> baseOnly = std::make_shared<Base>();
    std::shared_ptr<Derived> shouldFail = std::dynamic_pointer_cast<Derived>(baseOnly);

    if (!shouldFail)
        std::cout << "Sikertelen cast - nem Derived\n";
}

• Többféle származtatott típus tárolása shared_ptr<Base> kollekcióban (pl. std::vector<std::shared_ptr<Base>>), majd típusspecifikus feldolgozás.
• Dinamikus típusellenőrzés nélkülözhetetlen olyan kódokban, ahol futásidőben dől el, milyen típusú objektumra mutat a pointer.

1. Nem virtuális destruktor a bázisosztályban:

   class Base {}; // NINCS virtual ~Base()
   

   → dynamic_cast nem működik, vagy viselkedése nem definiált.

2. Nem ellenőrzi a visszatérési értéket:

   ptr->doSomething();  // Ha ptr nullptr, akkor crash
   

3. Nem használható unique_ptr-rel:

   • Ha unique_ptr-t akarsz dinamikusan castolni, azt kézzel kell megírni:

     std::unique_ptr<Base> base = std::make_unique<Derived>();
     Derived* raw = dynamic_cast<Derived*>(base.get());
     if (raw) {
         std::unique_ptr<Derived> derived(raw);
         base.release(); // Fontos!
     }
     

std::dynamic_pointer_cast az eredeti shared_ptr-ből származtat egy új shared_ptr-t, megtartva a reference countot, és dinamikus típusellenőrzést hajt végre dynamic_cast segítségével. Ha a konverzió sikeres, akkor új shared_ptr-t kapsz a leszármazott típusra, ha nem, akkor nullptr.

• A std::dynamic_pointer_cast dinamikus, biztonságos típuskonverzió shared_ptr típusok között.
• Futásidőben ellenőrzi a típust és nullptr-t ad vissza, ha a cast nem sikerül.
• Csak polimorf osztályokra működik (virtual metódus kötelező).
• Tökéletes választás öröklődésnél, amikor a tényleges típus csak futásidőben ismert.

• std::dynamic pointer cast - Szótár.net (en-hu)
• std::dynamic pointer cast - Sztaki (en-hu)
• std::dynamic pointer cast - Merriam–Webster
• std::dynamic pointer cast - Cambridge
• std::dynamic pointer cast - WordNet
• std::dynamic pointer cast - Яндекс (en-ru)
• std::dynamic pointer cast - Google (en-hu)
• std::dynamic pointer cast - Wikidata
• std::dynamic pointer cast - Wikipédia (angol)