Динамічне приведення типів (`dynamic_cast`) та RTTI

#include <iostream>
#include <string>

class Animal
{
protected:
    std::string name;

public:
    Animal(std::string n) : name(n) {}
    
    virtual std::string speak() const
    {
        return name + " видає звук";
    }
    
    virtual ~Animal() = default;
};

class Bird : public Animal
{
public:
    Bird(std::string n) : Animal(n) {}
    
    std::string speak() const override
    {
        return name + " співає: Чвірінь-чвірінь!";
    }
    
    // Метод, специфічний для Bird
    void fly() const
    {
        std::cout << name << " літає!\n";
    }
};

class Dog : public Animal
{
public:
    Dog(std::string n) : Animal(n) {}
    
    std::string speak() const override
    {
        return name + " гавкає: Гав-гав!";
    }
};

// Функція отримує Animal*, але нам потрібен доступ до Bird::fly()
void interactWithAnimal(Animal* animal)
{
    std::cout << animal->speak() << "\n";
    
    // ❓ Як викликати fly(), якщо animal насправді вказує на Bird?
    // animal->fly();  // ❌ Помилка компіляції: Animal не має методу fly()
}

int main()
{
    Bird sparrow("Горобець");
    Dog dog("Рекс");
    
    interactWithAnimal(&sparrow);
    interactWithAnimal(&dog);
    
    return 0;
}

#include <iostream>

class Base
{
public:
    virtual void print() const { std::cout << "Base\n"; }
    virtual ~Base() = default;
};

class Derived : public Base
{
public:
    void print() const override { std::cout << "Derived\n"; }
};

int main()
{
    Derived derived;
    
    // ✅ Upcasting: неявна конвертація Derived* → Base*
    Base* basePtr = &derived;
    
    // ✅ Upcasting: неявна конвертація Derived& → Base&
    Base& baseRef = derived;
    
    // Поліморфізм працює
    basePtr->print();  // Виведе "Derived"
    baseRef.print();   // Виведе "Derived"
    
    return 0;
}

#include <iostream>

class Base
{
public:
    virtual void print() const { std::cout << "Base\n"; }
    virtual ~Base() = default;
};

class Derived : public Base
{
public:
    void print() const override { std::cout << "Derived\n"; }
    void derivedMethod() { std::cout << "Специфічний метод Derived\n"; }
};

int main()
{
    Base base;
    Derived derived;
    
    Base* ptr1 = &derived;  // Вказує на Derived
    Base* ptr2 = &base;     // Вказує на Base
    
    // ❌ НЕБЕЗПЕЧНО: примусове приведення без перевірки
    Derived* downcast1 = (Derived*)ptr1;  // ✅ Працює: ptr1 насправді вказує на Derived
    downcast1->derivedMethod();
    
    Derived* downcast2 = (Derived*)ptr2;  // ❌ НЕБЕЗПЕЧНО: ptr2 вказує на Base!
    // downcast2->derivedMethod();  // Undefined Behavior: невалідний доступ до пам'яті
    
    return 0;
}

#include <iostream>
#include <string>

class Animal
{
protected:
    std::string name;

public:
    Animal(std::string n) : name(n) {}
    virtual ~Animal() = default;
};

class Bird : public Animal
{
public:
    Bird(std::string n) : Animal(n) {}
    
    void fly() const
    {
        std::cout << name << " літає!\n";
    }
};

class Dog : public Animal
{
public:
    Dog(std::string n) : Animal(n) {}
};

void interactWithAnimal(Animal* animal)
{
    // Спроба безпечного downcasting до Bird
    Bird* bird = dynamic_cast<Bird*>(animal);
    
    if (bird) {
        // ✅ animal насправді вказував на Bird
        bird->fly();
    } else {
        // ❌ animal НЕ є Bird
        std::cout << "Ця тварина не літає\n";
    }
}

int main()
{
    Bird sparrow("Горобець");
    Dog dog("Рекс");
    
    std::cout << "Взаємодія з горобцем:\n";
    interactWithAnimal(&sparrow);
    
    std::cout << "\nВзаємодія з собакою:\n";
    interactWithAnimal(&dog);
    
    return 0;
}

#include <iostream>
#include <typeinfo>  // для std::bad_cast

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

class Derived : public Base
{
public:
    void derivedMethod() { std::cout << "Метод Derived\n"; }
};

int main()
{
    Derived derivedObj;
    Base& baseRef = derivedObj;
    
    try {
        // ✅ Успішна конвертація
        Derived& derivedRef = dynamic_cast<Derived&>(baseRef);
        derivedRef.derivedMethod();
    }
    catch (const std::bad_cast& e) {
        std::cout << "Помилка приведення: " << e.what() << "\n";
    }
    
    Base baseObj;
    Base& baseRef2 = baseObj;
    
    try {
        // ❌ Невдала конвертація — генерується виняток
        Derived& derivedRef2 = dynamic_cast<Derived&>(baseRef2);
        derivedRef2.derivedMethod();
    }
    catch (const std::bad_cast& e) {
        std::cout << "Помилка приведення: " << e.what() << "\n";
    }
    
    return 0;
}

#include <iostream>

// ❌ Не поліморфний клас (немає віртуальних функцій)
class NonPolymorphic
{
public:
    int value;
};

class DerivedNonPoly : public NonPolymorphic
{
public:
    int extra;
};

// ✅ Поліморфний клас (є віртуальний деструктор)
class Polymorphic
{
public:
    int value;
    virtual ~Polymorphic() = default;  // Віртуальний деструктор
};

class DerivedPoly : public Polymorphic
{
public:
    int extra;
};

int main()
{
    // ❌ Помилка компіляції: NonPolymorphic не є поліморфним
    // NonPolymorphic* np = new DerivedNonPoly();
    // DerivedNonPoly* dnp = dynamic_cast<DerivedNonPoly*>(np);
    
    // ✅ Працює: Polymorphic є поліморфним
    Polymorphic* p = new DerivedPoly();
    DerivedPoly* dp = dynamic_cast<DerivedPoly*>(p);
    
    if (dp) {
        std::cout << "✅ Успішний dynamic_cast\n";
    }
    
    delete p;
    return 0;
}

#include <iostream>

enum class AnimalType { DOG, BIRD };

class Animal
{
public:
    virtual AnimalType getType() const = 0;
    virtual ~Animal() = default;
};

class Dog : public Animal
{
public:
    AnimalType getType() const override { return AnimalType::DOG; }
    void bark() { std::cout << "Гав-гав!\n"; }
};

class Bird : public Animal
{
public:
    AnimalType getType() const override { return AnimalType::BIRD; }
    void fly() { std::cout << "Літаю!\n"; }
};

void interact(Animal* animal)
{
    // Спочатку перевіряємо тип через віртуальний метод
    if (animal->getType() == AnimalType::DOG) {
        // ✅ Ми вже довели, що це Dog — static_cast безпечний
        Dog* dog = static_cast<Dog*>(animal);
        dog->bark();
    }
    else if (animal->getType() == AnimalType::BIRD) {
        Bird* bird = static_cast<Bird*>(animal);
        bird->fly();
    }
}

int main()
{
    Dog dog;
    Bird bird;
    
    interact(&dog);
    interact(&bird);
    
    return 0;
}

#include <iostream>
#include <vector>

class Shape
{
public:
    virtual double getArea() const = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape
{
private:
    double radius;

public:
    Circle(double r) : radius(r) {}
    
    double getArea() const override { return 3.14159 * radius * radius; }
    double getRadius() const { return radius; }
};

class Rectangle : public Shape
{
private:
    double width, height;

public:
    Rectangle(double w, double h) : width(w), height(h) {}
    
    double getArea() const override { return width * height; }
    double getWidth() const { return width; }
    double getHeight() const { return height; }
};

void analyzeShapes(const std::vector<Shape*>& shapes)
{
    for (Shape* shape : shapes) {
        std::cout << "Площа: " << shape->getArea() << " | ";
        
        // Спроба визначити, чи це коло
        if (Circle* circle = dynamic_cast<Circle*>(shape)) {
            std::cout << "Коло з радіусом " << circle->getRadius();
        }
        // Спроба визначити, чи це прямокутник
        else if (Rectangle* rect = dynamic_cast<Rectangle*>(shape)) {
            std::cout << "Прямокутник " << rect->getWidth() 
                      << "×" << rect->getHeight();
        }
        
        std::cout << "\n";
    }
}

int main()
{
    std::vector<Shape*> shapes = {
        new Circle(5.0),
        new Rectangle(4.0, 6.0),
        new Circle(3.0)
    };
    
    analyzeShapes(shapes);
    
    // Очищення
    for (Shape* shape : shapes) {
        delete shape;
    }
    
    return 0;
}

#include <iostream>
#include <typeinfo>

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

class Derived : public Base {};

int main()
{
    int i = 42;
    double d = 3.14;
    Base base;
    Derived derived;
    
    Base* ptrToBase = &base;
    Base* ptrToDerived = &derived;
    
    std::cout << "Тип i: " << typeid(i).name() << "\n";
    std::cout << "Тип d: " << typeid(d).name() << "\n";
    std::cout << "Тип base: " << typeid(base).name() << "\n";
    std::cout << "Тип derived: " << typeid(derived).name() << "\n";
    
    std::cout << "\nЧерез покажчики (поліморфні):\n";
    std::cout << "Тип *ptrToBase: " << typeid(*ptrToBase).name() << "\n";
    std::cout << "Тип *ptrToDerived: " << typeid(*ptrToDerived).name() << "\n";
    
    return 0;
}

#include <iostream>
#include <typeinfo>

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

class Dog : public Animal {};
class Cat : public Animal {};

void identifyAnimal(Animal* animal)
{
    if (typeid(*animal) == typeid(Dog)) {
        std::cout << "Це точно собака!\n";
    }
    else if (typeid(*animal) == typeid(Cat)) {
        std::cout << "Це точно кіт!\n";
    }
    else {
        std::cout << "Невідома тварина\n";
    }
}

int main()
{
    Dog dog;
    Cat cat;
    Animal animal;
    
    identifyAnimal(&dog);
    identifyAnimal(&cat);
    identifyAnimal(&animal);
    
    return 0;
}

#include <iostream>
#include <typeinfo>

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

int main()
{
    const std::type_info& ti1 = typeid(int);
    const std::type_info& ti2 = typeid(double);
    const std::type_info& ti3 = typeid(int);
    
    std::cout << "int == double: " << (ti1 == ti2) << "\n";
    std::cout << "int == int: " << (ti1 == ti3) << "\n";
    
    std::cout << "Hash int: " << ti1.hash_code() << "\n";
    std::cout << "Hash double: " << ti2.hash_code() << "\n";
    
    return 0;
}

void processShape(Shape* shape)
{
    if (Circle* circle = dynamic_cast<Circle*>(shape)) {
        // Спеціальна логіка для кола
        double area = 3.14159 * circle->getRadius() * circle->getRadius();
        std::cout << "Коло, площа: " << area << "\n";
    }
    else if (Rectangle* rect = dynamic_cast<Rectangle*>(shape)) {
        // Спеціальна логіка для прямокутника
        double area = rect->getWidth() * rect->getHeight();
        std::cout << "Прямокутник, площа: " << area << "\n";
    }
    else if (Triangle* tri = dynamic_cast<Triangle*>(shape)) {
        // Спеціальна логіка для трикутника
        double area = 0.5 * tri->getBase() * tri->getHeight();
        std::cout << "Трикутник, площа: " << area << "\n";
    }
}

class Shape
{
public:
    virtual double getArea() const = 0;
    virtual void print() const = 0;
    virtual ~Shape() = default;
};

class Circle : public Shape
{
private:
    double radius;

public:
    Circle(double r) : radius(r) {}
    
    double getArea() const override
    {
        return 3.14159 * radius * radius;
    }
    
    void print() const override
    {
        std::cout << "Коло, площа: " << getArea() << "\n";
    }
};

// Аналогічно для Rectangle, Triangle...

void processShape(Shape* shape)
{
    shape->print();  // ✅ Поліморфізм — кожна фігура сама знає, як себе виводити
}