Множинне наслідування та проблема ромба

#include <iostream>

using namespace std;

class Person
{
protected:
    string name;
    int age;

public:
    Person(string n, int a) : name(n), age(a)
    {
        cout << "  → Конструктор Person: " << name << "\n";
    }
    
    string getName() const { return name; }
    int getAge() const { return age; }
};

class Employee
{
protected:
    string employer;
    double salary;

public:
    Employee(string emp, double sal) : employer(emp), salary(sal)
    {
        cout << "  → Конструктор Employee: " << employer << "\n";
    }
    
    string getEmployer() const { return employer; }
    double getSalary() const { return salary; }
};

// Teacher успадковує від Person та Employee одночасно
class Teacher : public Person, public Employee
{
private:
    string subject;

public:
    Teacher(string n, int a, string emp, double sal, string subj)
        : Person(n, a), Employee(emp, sal), subject(subj)
    {
        cout << "  → Конструктор Teacher: предмет " << subject << "\n";
    }
    
    void displayInfo()
    {
        cout << "Вчитель: " << getName() << ", вік " << getAge() << "\n";
        cout << "Працює в: " << getEmployer() << "\n";
        cout << "Зарплата: " << getSalary() << " грн\n";
        cout << "Викладає: " << subject << "\n";
    }
};

int main()
{
    Teacher teacher("Олена Петрівна", 45, "Ліцей №7", 18000, "Математика");
    
    cout << "\nІнформація про вчителя:\n";
    teacher.displayInfo();
    
    return 0;
}

class Person
{
public:
    Person(string n) : name(n) {}
    ~Person() { cout << "  ← Деструктор Person\n"; }
};

class Employee
{
public:
    Employee(string e) : employer(e) {}
    ~Employee() { cout << "  ← Деструктор Employee\n"; }
};

class Teacher : public Person, public Employee
{
public:
    Teacher(string n, string e, string s)
        : Person(n), Employee(e), subject(s) {}
    ~Teacher() { cout << "  ← Деструктор Teacher\n"; }
};

int main()
{
    {
        Teacher teacher("Іван", "Школа", "Фізика");
    }
    cout << "Об'єкт знищено\n";
    return 0;
}

#include <iostream>

using namespace std;

class USBDevice
{
protected:
    long id;

public:
    USBDevice(long i) : id(i) {}
    
    long getId() const { return id; }
};

class NetworkDevice
{
protected:
    long id;

public:
    NetworkDevice(long i) : id(i) {}
    
    long getId() const { return id; }
};

class WirelessAdapter : public USBDevice, public NetworkDevice
{
public:
    WirelessAdapter(long usbId, long networkId)
        : USBDevice(usbId), NetworkDevice(networkId) {}
};

int main()
{
    WirelessAdapter adapter(5521, 8842);
    
    // cout << adapter.getId();  // ❌ Помилка компіляції: неоднозначність!
    
    // Потрібно явно вказати, який getId() викликати:
    cout << "USB ID: " << adapter.USBDevice::getId() << "\n";
    cout << "Network ID: " << adapter.NetworkDevice::getId() << "\n";
    
    return 0;
}

#include <iostream>

using namespace std;

class PoweredDevice
{
protected:
    int powerConsumption;

public:
    PoweredDevice(int power) : powerConsumption(power)
    {
        cout << "  → PoweredDevice: споживання " << power << " Вт\n";
    }
    
    int getPower() const { return powerConsumption; }
};

class Scanner : public PoweredDevice
{
public:
    Scanner(int power) : PoweredDevice(power)
    {
        cout << "  → Scanner\n";
    }
};

class Printer : public PoweredDevice
{
public:
    Printer(int power) : PoweredDevice(power)
    {
        cout << "  → Printer\n";
    }
};

class Copier : public Scanner, public Printer
{
public:
    Copier(int scannerPower, int printerPower)
        : Scanner(scannerPower), Printer(printerPower)
    {
        cout << "  → Copier\n";
    }
};

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

#include <iostream>

using namespace std;

class PoweredDevice
{
protected:
    int powerConsumption;

public:
    PoweredDevice(int power) : powerConsumption(power)
    {
        cout << "  → PoweredDevice: споживання " << power << " Вт\n";
    }
    
    int getPower() const { return powerConsumption; }
};

// Scanner віртуально успадковує PoweredDevice
class Scanner : virtual public PoweredDevice
{
public:
    Scanner(int power) : PoweredDevice(power)
    {
        cout << "  → Scanner\n";
    }
};

// Printer віртуально успадковує PoweredDevice
class Printer : virtual public PoweredDevice
{
public:
    Printer(int power) : PoweredDevice(power)
    {
        cout << "  → Printer\n";
    }
};

class Copier : public Scanner, public Printer
{
public:
    // Copier відповідає за створення віртуального базового класу!
    Copier(int power)
        : PoweredDevice(power),  // Явний виклик віртуального базового класу
          Scanner(power),        // Ці виклики PoweredDevice ігноруються
          Printer(power)
    {
        cout << "  → Copier\n";
    }
};

int main()
{
    Copier copier(75);
    
    cout << "\nСпоживання пристрою: " << copier.getPower() << " Вт\n";
    
    return 0;
}

#include <iostream>

using namespace std;

// Базовий клас — електронний пристрій
class ElectronicDevice
{
protected:
    string serialNumber;
    int warrantyMonths;

public:
    ElectronicDevice(string serial, int warranty)
        : serialNumber(serial), warrantyMonths(warranty)
    {
        cout << "  → ElectronicDevice: серійний номер " << serialNumber << "\n";
    }
    
    string getSerialNumber() const { return serialNumber; }
    int getWarranty() const { return warrantyMonths; }
    
    void displayInfo() const
    {
        cout << "Серійний номер: " << serialNumber << "\n";
        cout << "Гарантія: " << warrantyMonths << " місяців\n";
    }
};

// Камера — віртуально успадковує ElectronicDevice
class Camera : virtual public ElectronicDevice
{
protected:
    int megapixels;

public:
    Camera(string serial, int warranty, int mp)
        : ElectronicDevice(serial, warranty), megapixels(mp)
    {
        cout << "  → Camera: " << megapixels << " Мп\n";
    }
    
    int getMegapixels() const { return megapixels; }
};

// Мобільний телефон — віртуально успадковує ElectronicDevice
class MobilePhone : virtual public ElectronicDevice
{
protected:
    string phoneNumber;

public:
    MobilePhone(string serial, int warranty, string number)
        : ElectronicDevice(serial, warranty), phoneNumber(number)
    {
        cout << "  → MobilePhone: номер " << phoneNumber << "\n";
    }
    
    string getPhoneNumber() const { return phoneNumber; }
};

// Смартфон — успадковує Camera та MobilePhone
class Smartphone : public Camera, public MobilePhone
{
private:
    string operatingSystem;

public:
    Smartphone(string serial, int warranty, int mp, string number, string os)
        : ElectronicDevice(serial, warranty),  // Ініціалізуємо віртуальний базовий клас
          Camera(serial, warranty, mp),
          MobilePhone(serial, warranty, number),
          operatingSystem(os)
    {
        cout << "  → Smartphone: ОС " << operatingSystem << "\n";
    }
    
    void displayFullInfo() const
    {
        displayInfo();  // Викликає ElectronicDevice::displayInfo()
        cout << "Камера: " << megapixels << " Мп\n";
        cout << "Номер: " << phoneNumber << "\n";
        cout << "ОС: " << operatingSystem << "\n";
    }
};

int main()
{
    cout << "=== Створення смартфона ===\n\n";
    
    Smartphone phone("SM-2024-1234", 24, 108, "+380501234567", "Android 14");
    
    cout << "\n=== Інформація про пристрій ===\n";
    phone.displayFullInfo();
    
    return 0;
}