Специфікатор `protected` та види наслідування

#include <iostream>

using namespace std;

class Person
{
public:
    string name;  // Публічне поле — доступне всім

private:
    string passport;  // Приватне поле — доступне лише Person

protected:
    int age;  // Захищене поле — доступне Person та похідним класам
};

class Student : public Person
{
public:
    void celebrateBirthday()
    {
        age++;  // ✅ Дозволено: age є protected у базовому класі
        name += " (студент)";  // ✅ Дозволено: name є public
        // passport = "...";  // ❌ Помилка: passport є private у базовому класі
    }
};

int main()
{
    Person person;
    person.name = "Іван Петренко";  // ✅ Дозволено: name є public
    // person.age = 25;  // ❌ Помилка: age є protected — недоступний ззовні
    // person.passport = "AA123456";  // ❌ Помилка: passport є private
    
    Student student;
    student.name = "Марія Коваленко";  // ✅ Дозволено: name є public
    // student.age = 20;  // ❌ Помилка: age є protected — недоступний ззовні
    
    return 0;
}

#include <iostream>

using namespace std;

class Person
{
protected:
    string name;
    int age;

public:
    Person(string n, int a) : name(n), age(a)
    {
        if (age < 0) age = 0;  // Валідація при створенні
    }
    
    // Публічний інтерфейс для зовнішнього коду
    string getName() const { return name; }
    int getAge() const { return age; }
    
    void setAge(int a)
    {
        if (a >= 0 && a < 150) {
            age = a;
        }
    }
};

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

public:
    Student(string n, int a, string id, double g)
        : Person(n, a), studentId(id), gpa(g) {}
    
    void celebrateBirthday()
    {
        age++;  // ✅ Прямий доступ до protected-поля — просто і зрозуміло
        cout << name << " тепер " << age << " років!\n";
    }
    
    void updateProfile(string newName)
    {
        name = newName;  // ✅ Похідний клас може змінювати protected-поля
    }
    
    string getStudentId() const { return studentId; }
    double getGpa() const { return gpa; }
};

int main()
{
    Student student("Олена Сидоренко", 19, "CS-2024-0831", 4.5);
    
    cout << "Студент: " << student.getName() 
         << ", вік: " << student.getAge() << "\n";
    
    student.celebrateBirthday();
    
    // student.name = "Інше ім'я";  // ❌ Помилка: name є protected
    // student.age = 25;  // ❌ Помилка: age є protected
    
    student.setAge(20);  // ✅ Зміна через публічний метод з валідацією
    cout << "Оновлений вік: " << student.getAge() << "\n";
    
    return 0;
}

#include <iostream>

using namespace std;

class Base
{
public:
    int publicField;

protected:
    int protectedField;

private:
    int privateField;
};

class Derived : public Base  // Публічне наслідування
{
public:
    void testAccess()
    {
        publicField = 1;      // ✅ Дозволено: public залишається public
        protectedField = 2;   // ✅ Дозволено: protected залишається protected
        // privateField = 3;  // ❌ Помилка: private недоступний похідному класу
    }
};

int main()
{
    Base base;
    base.publicField = 10;       // ✅ Дозволено: public доступний ззовні
    // base.protectedField = 20; // ❌ Помилка: protected недоступний ззовні
    // base.privateField = 30;   // ❌ Помилка: private недоступний ззовні
    
    Derived derived;
    derived.publicField = 100;       // ✅ Дозволено: public залишився public у Derived
    // derived.protectedField = 200; // ❌ Помилка: protected недоступний ззовні
    // derived.privateField = 300;   // ❌ Помилка: private недоступний
    
    return 0;
}

#include <iostream>

using namespace std;

class Base
{
public:
    void publicMethod() { cout << "Base::publicMethod()\n"; }

protected:
    void protectedMethod() { cout << "Base::protectedMethod()\n"; }
};

class Derived : private Base  // Приватне наслідування
{
public:
    void testAccess()
    {
        publicMethod();     // ✅ Дозволено всередині Derived
        protectedMethod();  // ✅ Дозволено всередині Derived
    }
};

class FurtherDerived : public Derived
{
public:
    void testAccess()
    {
        // publicMethod();  // ❌ Помилка: publicMethod став private у Derived
        // protectedMethod();  // ❌ Помилка: protectedMethod став private у Derived
    }
};

int main()
{
    Base base;
    base.publicMethod();  // ✅ Дозволено: public метод базового класу
    
    Derived derived;
    // derived.publicMethod();  // ❌ Помилка: publicMethod став private у Derived
    derived.testAccess();  // ✅ Дозволено: викликає публічний метод Derived
    
    return 0;
}

class Base
{
public:
    void publicMethod() {}

protected:
    void protectedMethod() {}
};

class Derived : protected Base  // Захищене наслідування
{
    // publicMethod() тепер protected у Derived
    // protectedMethod() залишається protected
};

class FurtherDerived : public Derived
{
public:
    void test()
    {
        publicMethod();     // ✅ Дозволено: publicMethod тепер protected у Derived
        protectedMethod();  // ✅ Дозволено: protectedMethod залишився protected
    }
};

int main()
{
    Derived derived;
    // derived.publicMethod();  // ❌ Помилка: publicMethod став protected у Derived
    
    return 0;
}

#include <iostream>

using namespace std;

class A
{
public:
    int publicA;

protected:
    int protectedA;

private:
    int privateA;
};

class B : private A  // Приватне наслідування
{
    // publicA тепер private у B
    // protectedA тепер private у B
    // privateA недоступний у B

public:
    void testB()
    {
        publicA = 1;      // ✅ Дозволено: B бачить publicA (він успадкований)
        protectedA = 2;   // ✅ Дозволено: B бачить protectedA
        // privateA = 3;  // ❌ Помилка: privateA недоступний похідним класам
    }
};

class C : public B  // Публічне наслідування від B
{
public:
    void testC()
    {
        // publicA = 10;      // ❌ Помилка: publicA став private у B — C не бачить його
        // protectedA = 20;   // ❌ Помилка: protectedA став private у B
    }
};

int main()
{
    A a;
    a.publicA = 100;       // ✅ Дозволено
    // a.protectedA = 200; // ❌ Помилка
    
    B b;
    // b.publicA = 100;  // ❌ Помилка: publicA став private у B
    
    C c;
    // c.publicA = 100;  // ❌ Помилка: publicA недоступний через C
    
    return 0;
}