Для чего используются спецификаторы доступа (public, private, protected)?

Для чего используются спецификаторы доступа (public, private, protected)?

Спецификаторы доступа — это механизм инкапсуляции в C++, который контролирует видимость членов класса и строго разделяет интерфейс от реализации.

Три спецификатора доступа

public — члены доступны откуда угодно:

class BankAccount {
public:
    void deposit(double amount) {
        balance += amount;  // Интерфейс, который может использовать код
    }
private:
    double balance;
};

BankAccount acc;
acc.deposit(1000);  // ✓ Доступно
// acc.balance = -9999;  // ✗ Ошибка компиляции

private — члены доступны только внутри класса:

class SecureData {
private:
    std::string password;
    
    void validatePassword() {
        // Может использоваться только внутри класса
    }
};

protected — члены доступны в классе и наследниках:

class Animal {
protected:
    std::string name;  // Доступно для наследников
    void breath() {
        // Доступно для наследников
    }
private:
    int internalState;  // НЕ доступно для наследников
};

class Dog : public Animal {
public:
    void introduce() {
        std::cout << name << " says woof\n";  // ✓ protected доступно
    }
};

Для чего они нужны: принцип наименьших привилегий

1. Предотвращение неправильного использования

   // Без защиты — пользователь может сломать класс
   class BankAccount {
   public:
       double balance;  // ОПАСНО! Любой может изменить
   };
   acc.balance = -50000;  // Теперь счёт отрицательный!
   
   // С private — обеспечиваем инварианты класса
   class BankAccount {
   private:
       double balance;
   public:
       void withdraw(double amount) {
           if (amount <= balance) {
               balance -= amount;
           }
       }
   };
   

2. Контроль инвариантов класса Класс гарантирует, что его данные всегда в согласованном состоянии:

   class Stack {
   private:
       std::vector<int> data;
       int size;
       
       void ensureInvariant() {
           assert(size <= data.capacity());
       }
   public:
       void push(int val) {
           data.push_back(val);
           size++;
           ensureInvariant();  // Гарантируем консистентность
       }
   };
   

3. Изменение реализации без влияния на клиентов

   class CachedValue {
   private:
       int cachedValue;
       bool isDirty;
       
       void recompute() {
           // Только класс знает о деталях кеширования
       }
   public:
       int getValue() {
           if (isDirty) recompute();
           return cachedValue;
       }
   };
   
   // Если потом решим изменить стратегию кеширования,
   // клиентский код не будет затронут
   

4. Логическое разделение интерфейса и реализации

   class ComplexNumber {
   public:
       // Публичный интерфейс — простой и понятный
       ComplexNumber(double real, double imag);
       ComplexNumber operator+(const ComplexNumber& other) const;
       double magnitude() const;
   private:
       // Приватная реализация — может меняться
       double real, imag;
       // Или внутри: std::complex<double> value;
   };
   

Protected в наследовании

Protected используется для создания контролируемого интерфейса для наследников:

class Shape {
protected:
    void notifyObservers() {
        // Метод доступен для наследников для расширения функциональности
    }
private:
    std::vector<Observer*> observers;  // Скрыто даже от наследников
};

class Circle : public Shape {
public:
    void setRadius(double r) {
        radius = r;
        notifyObservers();  // ✓ Может вызвать
    }
private:
    double radius;
};

Правила хорошего дизайна

• По умолчанию: private — открывай только то, что нужно наружу
• public interface должен быть маленьким и ясным
• protected используй для расширения наследниками, не для скрытия реализации
• Getter/setter для контролируемого доступа:

  class Temperature {
  private:
      double kelvin;
  public:
      void setCelsius(double celsius) {
          kelvin = celsius + 273.15;
      }
      double getCelsius() const {
          return kelvin - 273.15;
      }
  };
  

Итого

Спецификаторы доступа — не просто синтаксис, а архитектурный инструмент для:

• Защиты инвариантов класса
• Разделения public API от деталей реализации
• Упрощения рефакторинга
• Уменьшения неправильного использования