Inheritance Downcasting is Dangerous

#include<iostream>

class Base
{
public:

    Base() {
        std::cout << "Base constructor" << std::endl;
    }
    void foo()
    {
        std::cout << "Base::foo" << std::endl;
    }

    virtual ~Base()
    {
        std::cout << "Base destructor" << std::endl;
    }
};


class Derived : public Base
{
public:
    void foo()
    {
        std::cout << "Derived::foo" << std::endl;
    }

    Derived() {
        std::cout << "Derived constructor" << std::endl;
    }


    ~Derived()
    {
        std::cout << "Derived destructor" << std::endl;
    }
};


int main()
{


    Base* base_ptr = new Base();   // OBJECT IS BASE - NOT DERIVED
    Derived* derived_ptr = static_cast<Derived*>(base_ptr); // DANGER!
    // The cast would succeed because static_cast performs no runtime check.
    //  However, derived_ptr would point to an object 
    // that is only a Base but is being treated as a Derived. 



    // Now accessing Derived-specific members (like foo() if it touches Derived data) 
    // leads to undefined behavior and likely memory corruption or a crash.
    derived_ptr->foo();


    return 0;
}

    Derived* derived_ptr = dynamic_cast<Derived*>(base_ptr);
    
    if (derived_ptr) {
        // This code block is NOT executed because the cast failed
        derived_ptr->foo(); 
    } else {
        std::cout << "ERROR: Cast failed! Object is not a Derived. " << "\n">>;
}