# private、public、protected

URL: https://caijiao.org/cpp/oop/access
Source: docs/cpp/oop/access.md
Description: 本节讲解 C++ 中的访问修饰符（'private'、'public'、'protected'），它们控制类成员的访问权限。了解这些修饰符的用法可以帮助你更好地封装类的内部实现，保护数据不被外部错误修改。

在 C++ 中，类成员的访问权限由访问修饰符（`private`、`public`、`protected`）来控制。通过合理使用这些修饰符，可以实现类的封装性，保护类的数据和功能免受外部错误访问。

## `public`

`public` 是最常用的访问修饰符，它指定类成员对外部可见。使用 `public` 修饰的成员可以被任何代码访问，无论是类的外部还是内部。

### 示例：使用 `public`

```cpp
#include <iostream>
using namespace std;

class Person {
public:
    string name;  // 公共成员
    int age;      // 公共成员

    void introduce() {  // 公共成员函数
        cout << "Hello, my name is " << name << " and I am " << age << " years old." << endl;
    }
};

int main() {
    Person person;
    person.name = "Alice";
    person.age = 25;
    person.introduce(); // 访问公共成员和成员函数
    return 0;
}
````

### 输出：

```
Hello, my name is Alice and I am 25 years old.
```

在上面的代码中，`name`、`age` 和 `introduce()` 都是 `public` 成员，可以在类外部直接访问。

## `private`

`private` 修饰符用于限制类成员的访问权限。使用 `private` 修饰的成员只能在类的内部访问，外部代码无法直接访问它们。这是数据封装的核心，目的是保护对象的内部状态不被外部代码修改。

### 示例：使用 `private`

```cpp
#include <iostream>
using namespace std;

class Person {
private:
    string name;  // 私有成员
    int age;      // 私有成员

public:
    void setName(string n) {  // 公共成员函数，设置私有成员
        name = n;
    }

    void setAge(int a) {  // 公共成员函数，设置私有成员
        age = a;
    }

    void introduce() {
        cout << "Hello, my name is " << name << " and I am " << age << " years old." << endl;
    }
};

int main() {
    Person person;
    person.setName("Bob");  // 通过公共方法访问私有成员
    person.setAge(30);
    person.introduce();
    return 0;
}
```

### 输出：

```
Hello, my name is Bob and I am 30 years old.
```

在这个例子中，`name` 和 `age` 是 `private` 成员，无法在类外部直接访问。外部代码必须通过公共成员函数（如 `setName` 和 `setAge`）来访问这些私有成员。

## `protected`

`protected` 修饰符介于 `private` 和 `public` 之间。使用 `protected` 修饰的成员可以在类的内部访问，并且可以被任何派生类访问，但无法通过类的外部代码访问。通常在继承中使用，允许子类访问父类的某些成员。

### 示例：使用 `protected`

```cpp
#include <iostream>
using namespace std;

class Base {
protected:
    string name;  // 保护成员
};

class Derived : public Base {
public:
    void setName(string n) {
        name = n;  // 子类可以访问基类的 protected 成员
    }

    void introduce() {
        cout << "Hello, my name is " << name << "." << endl;
    }
};

int main() {
    Derived derived;
    derived.setName("Charlie");  // 通过公共方法访问 protected 成员
    derived.introduce();
    return 0;
}
```

### 输出：

```
Hello, my name is Charlie.
```

在此例中，`name` 是基类 `Base` 的 `protected` 成员，只有 `Base` 和 `Derived` 类能访问它，外部无法直接访问。

## 总结

* **`public`**：类成员对外部可见，任何代码都可以访问。
* **`private`**：类成员只能在类内部访问，外部无法访问。
* **`protected`**：类成员可以在类内部和派生类中访问，但外部代码不能访问。

通过使用这些访问修饰符，C++ 提供了灵活的封装机制，帮助开发者控制类的数据访问权限，从而提高代码的安全性和可维护性。