.
在C++中，将成员变量声明为private而不是public，主要是为了遵循面向对象编程（OOP）的封装原则。他有助于隐藏对象的内部实现细节，提供更好地控制，安全性和可维护性。

1、数据隐藏与封装

• 将成员变量声明为private可以隐藏类的内部实现细节，防止外部代码直接访问或修改這些变量。同时，类的实现细节可以在不影响外部代码的情况下进行修改。

class BankAccount {
private:
    double balance;  // 余额是私有的，外部无法直接访问

public:
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    double getBalance() const {
        return balance;
    }
};

int main() {
    BankAccount account;
    account.deposit(100.0);
    // account.balance = 1000.0;  // 错误：balance是私有的，无法直接访问
    std::cout << "Balance: " << account.getBalance() << std::endl;
    return 0;
}

2、数据验证与控制

• 在设置或修改這些变量时，可以进行验证和控制，确保数据的有效性

class Person {
private:
    int age;

public:
    void setAge(int newAge) {
        if (newAge >= 0 && newAge <= 120) {  // 年龄的有效性检查
            age = newAge;
        } else {
            std::cout << "Invalid age!" << std::endl;
        }
    }

    int getAge() const {
        return age;
    }
};

int main() {
    Person person;
    person.setAge(25);
    // person.age = -10;  // 错误：age是私有的，无法直接访问
    std::cout << "Age: " << person.getAge() << std::endl;
    return 0;
}

3、减少耦合

• 减少类与外部代码之间的耦合。外部代码不需要知道类的内部实现细节，只需要通过公共接口与类进行交互

class Car {
private:
    int speed;

public:
    void accelerate(int increment) {
        speed += increment;
    }

    void brake(int decrement) {
        speed -= decrement;
    }

    int getSpeed() const {
        return speed;
    }
};

int main() {
    Car car;
    car.accelerate(20);
    car.brake(5);
    // car.speed = 100;  // 错误：speed是私有的，无法直接访问
    std::cout << "Current speed: " << car.getSpeed() << std::endl;
    return 0;
}

4、便于维护与扩展

• 如果要修改类的内部实现，只要公共接口保持不变，外部代码就不需要修改。

class Rectangle {
private:
    int width;
    int height;

public:
    void setDimensions(int w, int h) {
        width = w;
        height = h;
    }

    int getArea() const {
        return width * height;
    }
};

int main() {
    Rectangle rect;
    rect.setDimensions(10, 20);
    // rect.width = 5;  // 错误：width是私有的，无法直接访问
    std::cout << "Area: " << rect.getArea() << std::endl;
    return 0;
}

5、防止误用

• 防止外部代码误用或滥用类的内部数据，提供代码的健壮性。

class Date {
private:
    int day;
    int month;
    int year;

public:
    void setDate(int d, int m, int y) {
        if (isValidDate(d, m, y)) {
            day = d;
            month = m;
            year = y;
        } else {
            std::cout << "Invalid date!" << std::endl;
        }
    }

    void printDate() const {
        std::cout << day << "/" << month << "/" << year << std::endl;
    }

private:
    bool isValidDate(int d, int m, int y) const {
        // 简单的日期有效性检查
        if (d < 1 || d > 31 || m < 1 || m > 12 || y < 1900) {
            return false;
        }
        return true;
    }
};

int main() {
    Date date;
    date.setDate(15, 10, 2023);
    // date.day = 40;  // 错误：day是私有的，无法直接访问
    date.printDate();
    return 0;
}

思维导图笔记：