Зрізка об'єктів, віртуальне наслідування та поліморфний вивід

#include <iostream>

class Animal
{
protected:
    std::string name;

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

class Dog : public Animal
{
private:
    std::string breed;

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

// ❌ Функція приймає Animal ЗА ЗНАЧЕННЯМ
void printAnimalSound(Animal animal)
{
    std::cout << animal.speak() << "\n";
}

int main()
{
    Dog dog("Рекс", "німецька вівчарка");
    
    // Передаємо Dog у функцію, що очікує Animal за значенням
    printAnimalSound(dog);
    
    return 0;
}

#include <iostream>

class Base
{
protected:
    int baseData;

public:
    Base(int data) : baseData(data)
    {
        std::cout << "Base конструктор: baseData = " << baseData << "\n";
    }
    
    virtual void display() const
    {
        std::cout << "[Base] baseData = " << baseData << "\n";
    }
    
    virtual ~Base() = default;
};

class Derived : public Base
{
private:
    int derivedData;
    double extraValue;

public:
    Derived(int base, int derived, double extra)
        : Base(base), derivedData(derived), extraValue(extra)
    {
        std::cout << "Derived конструктор: derivedData = " << derivedData 
                  << ", extraValue = " << extraValue << "\n";
    }
    
    void display() const override
    {
        std::cout << "[Derived] baseData = " << baseData 
                  << ", derivedData = " << derivedData 
                  << ", extraValue = " << extraValue << "\n";
    }
};

int main()
{
    std::cout << "=== Створення об'єкта Derived ===\n";
    Derived derived(10, 20, 3.14);
    
    std::cout << "\n=== Виклик через посилання (правильно) ===\n";
    Base& refBase = derived;
    refBase.display();  // ✅ Поліморфізм працює
    
    std::cout << "\n=== Присвоєння за значенням (зрізка!) ===\n";
    Base slicedBase = derived;  // ❌ Зрізка об'єкта
    slicedBase.display();  // Викличеться Base::display()
    
    std::cout << "\nРозмір Base:    " << sizeof(Base) << " байт\n";
    std::cout << "Розмір Derived: " << sizeof(Derived) << " байт\n";
    
    return 0;
}

#include <iostream>
#include <vector>

class Shape
{
public:
    virtual std::string getType() const { return "Shape"; }
    virtual ~Shape() = default;
};

class Circle : public Shape
{
public:
    std::string getType() const override { return "Circle"; }
};

class Rectangle : public Shape
{
public:
    std::string getType() const override { return "Rectangle"; }
};

int main()
{
    std::vector<Shape> shapes;  // ❌ Вектор зберігає Shape за значенням
    
    shapes.push_back(Circle());     // Зрізка: Circle → Shape
    shapes.push_back(Rectangle());  // Зрізка: Rectangle → Shape
    
    for (const Shape& shape : shapes) {
        std::cout << shape.getType() << "\n";  // Завжди виводить "Shape"
    }
    
    return 0;
}

std::vector<Shape*> shapes;

shapes.push_back(new Circle());
shapes.push_back(new Rectangle());

for (const Shape* shape : shapes) {
    std::cout << shape->getType() << "\n";  // ✅ Поліморфізм працює
}

// Обов'язкове очищення
for (Shape* shape : shapes) {
    delete shape;
}

#include <iostream>

class Shape
{
public:
    // Заборона конструктора копіювання
    Shape(const Shape&) = delete;
    
    // Заборона оператора присвоювання
    Shape& operator=(const Shape&) = delete;
    
    // Віртуальний деструктор обов'язковий
    virtual ~Shape() = default;
    
    virtual std::string getType() const = 0;

protected:
    // Дозволити похідним класам викликати дефолтний конструктор
    Shape() = default;
};

class Circle : public Shape
{
public:
    std::string getType() const override { return "Circle"; }
};

int main()
{
    Circle c1;
    
    // ❌ Помилка компіляції: копіювання заборонене
    // Shape shape = c1;
    
    // ✅ Посилання та покажчики дозволені
    Shape& ref = c1;
    Shape* ptr = &c1;
    
    std::cout << ref.getType() << "\n";
    std::cout << ptr->getType() << "\n";
    
    return 0;
}

#include <iostream>

class Device
{
protected:
    int powerRating;

public:
    Device(int power) : powerRating(power)
    {
        std::cout << "Device конструктор: power = " << power << "\n";
    }
    
    int getPower() const { return powerRating; }
};

class Printer : public Device
{
public:
    Printer(int power) : Device(power)
    {
        std::cout << "Printer конструктор\n";
    }
};

class Scanner : public Device
{
public:
    Scanner(int power) : Device(power)
    {
        std::cout << "Scanner конструктор\n";
    }
};

class Copier : public Printer, public Scanner
{
public:
    Copier(int printerPower, int scannerPower)
        : Printer(printerPower), Scanner(scannerPower)
    {
        std::cout << "Copier конструктор\n";
    }
};

int main()
{
    Copier copier(100, 50);
    
    // ❌ Помилка компіляції: неоднозначність
    // std::cout << copier.getPower();
    
    // Потрібна явна кваліфікація
    std::cout << "Printer power: " << copier.Printer::getPower() << "\n";
    std::cout << "Scanner power: " << copier.Scanner::getPower() << "\n";
    
    return 0;
}

#include <iostream>

class Device
{
protected:
    int powerRating;

public:
    Device(int power) : powerRating(power)
    {
        std::cout << "Device конструктор: power = " << power << "\n";
    }
    
    int getPower() const { return powerRating; }
};

// virtual public Device — віртуальне наслідування
class Printer : virtual public Device
{
public:
    Printer(int power) : Device(power)
    {
        std::cout << "Printer конструктор\n";
    }
};

// virtual public Device — віртуальне наслідування
class Scanner : virtual public Device
{
public:
    Scanner(int power) : Device(power)
    {
        std::cout << "Scanner конструктор\n";
    }
};

class Copier : public Printer, public Scanner
{
public:
    // Найбільш похідний клас викликає конструктор віртуальної бази напряму
    Copier(int power)
        : Device(power),           // ✅ Copier відповідає за Device
          Printer(power),          // Цей виклик ігнорується
          Scanner(power)           // Цей виклик ігнорується
    {
        std::cout << "Copier конструктор\n";
    }
};

int main()
{
    Copier copier(120);
    
    // ✅ Тепер немає неоднозначності — Device існує в одному екземплярі
    std::cout << "Power: " << copier.getPower() << "\n";
    
    std::cout << "\nРозмір Copier: " << sizeof(Copier) << " байт\n";
    
    return 0;
}

class Employee
{
protected:
    std::string name;
    int id;

public:
    Employee(std::string n, int i) : name(n), id(i) {}
    
    virtual ~Employee() = default;
    
    friend std::ostream& operator<<(std::ostream& out, const Employee& emp)
    {
        return emp.print(out);
    }
    
    virtual std::ostream& print(std::ostream& out) const
    {
        out << "[ID: " << id << "] " << name;
        return out;
    }
};

class Manager : public Employee
{
private:
    int teamSize;

public:
    Manager(std::string n, int i, int size)
        : Employee(n, i), teamSize(size) {}
    
    std::ostream& print(std::ostream& out) const override
    {
        Employee::print(out);  // Виклик базової версії
        out << ", Team: " << teamSize << " осіб";
        return out;
    }
};

int main()
{
    Manager manager("Олена Коваль", 101, 8);
    
    Employee& empRef = manager;
    std::cout << empRef << "\n";
    
    return 0;
}