Что такое private?

Private в C++

private — это модификатор доступа (access specifier), который определяет видимость членов класса. Члены, объявленные как private, доступны только внутри самого класса и его друзей (friend классов/функций).

Основные концепции

class MyClass {
private:        // Всё ниже видно только для самого класса
    int secret_value;
    void internal_method() {}

public:         // Видно для всех
    void public_method() {
        secret_value = 42;  // OK, это внутри класса
        internal_method();  // OK
    }
};

int main() {
    MyClass obj;
    obj.secret_value = 10;      // ОШИБКА: не доступен
    obj.internal_method();      // ОШИБКА: не доступен
    obj.public_method();        // OK
}

Три уровня доступа в C++

1. public — доступен для всех (снаружи и внутри класса)
2. protected — доступен для класса, наследников и друзей
3. private — доступен только для самого класса и друзей

class Base {
public:
    int pub = 1;      // Видно везде

protected:
    int prot = 2;     // Видно для наследников

private:
    int priv = 3;     // Видно только для Base
};

class Derived : public Base {
    void test() {
        pub = 10;     // OK
        prot = 20;    // OK (наследник видит protected)
        priv = 30;    // ОШИБКА: private из Base не видит Derived
    }
};

Friend декларация

friend позволяет другим классам/функциям получить доступ к private:

class SecretVault {
private:
    int password = 12345;
    friend void steal_password(SecretVault& vault);  // Друг может читать
    friend class Hacker;  // Хакер может читать всё
};

void steal_password(SecretVault& vault) {
    std::cout << vault.password;  // OK, мы друзья
}

class Hacker {
public:
    void crack(SecretVault& vault) {
        std::cout << vault.password;  // OK
    }
};

Инкапсуляция (Encapsulation)

private — основной инструмент инкапсуляции, главного принципа ОО-программирования:

class BankAccount {
private:
    double balance;  // Нельзя напрямую менять

    bool is_sufficient_funds(double amount) {
        return balance >= amount;
    }

public:
    BankAccount(double initial_balance) 
        : balance(initial_balance) {}

    void withdraw(double amount) {
        if (is_sufficient_funds(amount)) {
            balance -= amount;  // Валидация через метод
        } else {
            throw std::runtime_error("Insufficient funds");
        }
    }

    double get_balance() const {
        return balance;  // Контролируемый доступ
    }
};

int main() {
    BankAccount account(1000);
    account.withdraw(100);  // OK, проходит валидацию
    account.balance = -999; // ОШИБКА: private
}

Геттеры и сеттеры

private обычно сочетается с public методами для контролируемого доступа:

class Temperature {
private:
    double celsius;

public:
    void set_celsius(double c) {
        if (c < -273.15) {
            throw std::invalid_argument("Below absolute zero!");
        }
        celsius = c;
    }

    double get_celsius() const {
        return celsius;
    }

    double get_fahrenheit() const {
        return celsius * 9.0 / 5.0 + 32;
    }
};

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

class Base {
private:
    int secret;  // Недоступен для наследников
};

class Derived : private Base {  // private наследование
    void test() {
        secret = 10;  // ОШИБКА
    }
};

Практические преимущества private

1. Инкапсуляция — скрыта реализация, видна только интерфейс
2. Защита инвариантов — внутренние проверки при изменении состояния
3. Гибкость рефакторинга — можно менять внутреннее устройство без изменения API
4. Контроль версионирования — private методы можно безопасно менять

class Vector {
private:
    float* data;
    size_t capacity;

    void ensure_capacity(size_t needed) {  // private, детали реализации
        if (needed > capacity) {
            reallocate(needed);
        }
    }

public:
    void push_back(float value) {
        ensure_capacity(size + 1);  // Используем внутренний метод
        data[size++] = value;
    }
};

Классы по умолчанию (struct vs class)

struct MyStruct {
    int x;  // По умолчанию public (struct)
};

class MyClass {
    int x;  // По умолчанию private (class)
};

MyStruct s;
s.x = 10;  // OK

MyClass c;
c.x = 10;  // ОШИБКА

Вывод: private — это фундаментальный инструмент для создания надёжного, безопасного и поддерживаемого C++ кода, обеспечивающий инкапсуляцию и контроль доступа к внутреннему состоянию объекта.