Перевизначення методів та приховування імен

#include <iostream>

using namespace std;

class Grandparent
{
public:
    void identify()
    {
        cout << "Я Grandparent\n";
    }
};

class Parent : public Grandparent
{
public:
    // У Parent немає власного методу identify()
};

class Child : public Parent
{
public:
    // У Child немає власного методу identify()
};

int main()
{
    Grandparent grandparent;
    grandparent.identify();  // Виклик Grandparent::identify()
    
    Parent parent;
    parent.identify();  // Пошук: Parent (немає) → Grandparent (є!) → використовуємо
    
    Child child;
    child.identify();  // Пошук: Child (немає) → Parent (немає) → Grandparent (є!)
    
    return 0;
}

#include <iostream>

using namespace std;

class Vehicle
{
protected:
    string brand;

public:
    Vehicle(string b) : brand(b) {}
    
    void identify()
    {
        cout << "Я транспортний засіб марки " << brand << "\n";
    }
};

class Car : public Vehicle
{
public:
    Car(string b) : Vehicle(b) {}
    
    // Перевизначення методу identify()
    void identify()
    {
        cout << "Я легковий автомобіль марки " << brand << "\n";
    }
};

class Truck : public Vehicle
{
public:
    Truck(string b) : Vehicle(b) {}
    
    // Перевизначення методу identify()
    void identify()
    {
        cout << "Я вантажівка марки " << brand << "\n";
    }
};

int main()
{
    Vehicle vehicle("Generic");
    vehicle.identify();
    
    Car car("Toyota");
    car.identify();  // Викликається Car::identify(), а не Vehicle::identify()
    
    Truck truck("Volvo");
    truck.identify();  // Викликається Truck::identify()
    
    return 0;
}

#include <iostream>

using namespace std;

class Base
{
private:
    void secretMethod()
    {
        cout << "Base::secretMethod() (private)\n";
    }

public:
    void callSecret()
    {
        secretMethod();  // ✅ Дозволено всередині Base
    }
};

class Derived : public Base
{
public:
    // Перевизначаємо secretMethod() як public
    void secretMethod()
    {
        cout << "Derived::secretMethod() (public)\n";
    }
};

int main()
{
    Base base;
    // base.secretMethod();  // ❌ Помилка: метод private у Base
    
    Derived derived;
    derived.secretMethod();  // ✅ Дозволено: метод public у Derived
    
    return 0;
}

#include <iostream>

using namespace std;

class Person
{
protected:
    string name;
    int age;

public:
    Person(string n, int a) : name(n), age(a) {}
    
    void introduce()
    {
        cout << "Мене звати " << name << ", мені " << age << " років.\n";
    }
};

class Student : public Person
{
private:
    string university;
    double gpa;

public:
    Student(string n, int a, string uni, double g)
        : Person(n, a), university(uni), gpa(g) {}
    
    void introduce()
    {
        // Спочатку викликаємо базову версію
        Person::introduce();
        
        // Потім додаємо власну інформацію
        cout << "Я студент університету " << university 
             << " із середнім балом " << gpa << ".\n";
    }
};

int main()
{
    Person person("Олег Коваль", 45);
    person.introduce();
    
    cout << "\n";
    
    Student student("Марія Сидоренко", 20, "КПІ", 4.7);
    student.introduce();
    
    return 0;
}

#include <iostream>

using namespace std;

class Base
{
public:
    void print()
    {
        cout << "Base::print() без параметрів\n";
    }
    
    void print(int value)
    {
        cout << "Base::print(int): " << value << "\n";
    }
    
    void print(double value)
    {
        cout << "Base::print(double): " << value << "\n";
    }
};

class Derived : public Base
{
public:
    // Перевизначаємо лише одну версію print()
    void print()
    {
        cout << "Derived::print() без параметрів\n";
    }
};

int main()
{
    Base base;
    base.print();        // ✅ Викликається Base::print()
    base.print(42);      // ✅ Викликається Base::print(int)
    base.print(3.14);    // ✅ Викликається Base::print(double)
    
    Derived derived;
    derived.print();     // ✅ Викликається Derived::print()
    // derived.print(42);   // ❌ Помилка компіляції!
    // derived.print(3.14); // ❌ Помилка компіляції!
    
    return 0;
}

#include <iostream>

using namespace std;

class Base
{
public:
    void print()
    {
        cout << "Base::print()\n";
    }
    
    void print(int value)
    {
        cout << "Base::print(int): " << value << "\n";
    }
    
    void print(double value)
    {
        cout << "Base::print(double): " << value << "\n";
    }
};

class Derived : public Base
{
public:
    using Base::print;  // Робимо всі версії print() з Base видимими
    
    // Перевизначаємо лише одну версію
    void print()
    {
        cout << "Derived::print()\n";
    }
};

int main()
{
    Derived derived;
    derived.print();      // ✅ Викликається Derived::print()
    derived.print(42);    // ✅ Викликається Base::print(int) — тепер видима!
    derived.print(3.14);  // ✅ Викликається Base::print(double)
    
    return 0;
}

#include <iostream>

using namespace std;

class Base
{
protected:
    void protectedMethod()
    {
        cout << "Base::protectedMethod() — захищений метод\n";
    }
};

class Derived : public Base
{
public:
    using Base::protectedMethod;  // Робимо protectedMethod() публічним у Derived
};

int main()
{
    Base base;
    // base.protectedMethod();  // ❌ Помилка: метод protected у Base
    
    Derived derived;
    derived.protectedMethod();  // ✅ Дозволено: метод public у Derived
    
    return 0;
}

#include <iostream>

using namespace std;

class Base
{
public:
    void allowedMethod()
    {
        cout << "Base::allowedMethod() — дозволено\n";
    }
    
    void restrictedMethod()
    {
        cout << "Base::restrictedMethod() — обмежено\n";
    }
};

class Derived : public Base
{
public:
    // Забороняємо виклик restrictedMethod() через об'єкти Derived
    void restrictedMethod() = delete;
};

int main()
{
    Base base;
    base.allowedMethod();      // ✅ Дозволено
    base.restrictedMethod();   // ✅ Дозволено: метод доступний через Base
    
    Derived derived;
    derived.allowedMethod();      // ✅ Дозволено: метод успадкований і не видалений
    // derived.restrictedMethod();  // ❌ Помилка компіляції: метод видалений у Derived
    
    return 0;
}

#include <iostream>
#include <cmath>

using namespace std;

class Shape
{
protected:
    string name;

public:
    Shape(string n) : name(n) {}
    
    void describe()
    {
        cout << "Фігура: " << name << "\n";
    }
    
    // Базова версія — для фігур без конкретних розмірів
    virtual double getArea()
    {
        cout << "Площа не визначена для базового класу Shape\n";
        return 0.0;
    }
};

class Circle : public Shape
{
private:
    double radius;

public:
    Circle(double r) : Shape("Коло"), radius(r) {}
    
    // Перевизначаємо метод describe() — розширюємо його
    void describe()
    {
        Shape::describe();  // Викликаємо базову версію
        cout << "Радіус: " << radius << " см\n";
    }
    
    // Перевизначаємо метод getArea()
    double getArea()
    {
        return M_PI * radius * radius;
    }
};

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

public:
    Rectangle(double w, double h) : Shape("Прямокутник"), width(w), height(h) {}
    
    void describe()
    {
        Shape::describe();
        cout << "Ширина: " << width << " см, Висота: " << height << " см\n";
    }
    
    double getArea()
    {
        return width * height;
    }
};

int main()
{
    Circle circle(5.0);
    circle.describe();
    cout << "Площа: " << circle.getArea() << " см²\n\n";
    
    Rectangle rectangle(4.0, 6.0);
    rectangle.describe();
    cout << "Площа: " << rectangle.getArea() << " см²\n\n";
    
    return 0;
}