编辑“︁C++ 访问修饰符”︁

= C++访问修饰符 =

'''访问修饰符'''（Access Modifiers）是C++面向对象编程中控制类成员（属性和方法）可见性的关键机制。它们定义了类成员在类外部及其他类中的可访问范围，是实现'''封装性'''这一OOP核心特性的重要工具。

== 访问修饰符类型 ==
C++提供三种访问修饰符：

{| class="wikitable"
|-
! 修饰符 !! 作用域 !! 可访问性
|-
| <code>public</code> || 公有 || 类内、派生类、类外均可访问
|-
| <code>private</code> || 私有 || 仅类内和友元可访问（默认修饰符）
|-
| <code>protected</code> || 保护 || 类内和派生类可访问
|}

=== 访问范围示意图 ===
<mermaid>
classDiagram
    class Example {
        +publicField
        -privateField
        #protectedField
        +publicMethod()
        -privateMethod()
        #protectedMethod()
    }
    Example <|-- DerivedClass
    note for Example "privateMethod()仅Example类内可调用"
    note for DerivedClass "可访问protectedField和protectedMethod()"
</mermaid>

== 详细说明 ==

=== public（公有成员） ===
公有成员构成类的'''接口'''，允许在任何上下文中访问。

<syntaxhighlight lang="cpp">
#include <iostream>
using namespace std;

class Circle {
public:
    double radius;
    double getArea() {
        return 3.14159 * radius * radius;
    }
};

int main() {
    Circle c;
    c.radius = 5.0;  // 直接访问public成员
    cout << "Area: " << c.getArea(); // 输出: Area: 78.5397
    return 0;
}
</syntaxhighlight>

=== private（私有成员） ===
私有成员实现'''数据隐藏'''，只能通过类的公有方法访问。

<syntaxhighlight lang="cpp">
class BankAccount {
private:
    double balance;  // 封装敏感数据

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

int main() {
    BankAccount acc;
    // acc.balance = 1000;  // 错误：private成员不可直接访问
    acc.deposit(500);
    cout << acc.getBalance();  // 正确：通过公有方法访问
}
</syntaxhighlight>

=== protected（保护成员） ===
保护成员在继承体系中可见，但对类外不可见。

<syntaxhighlight lang="cpp">
class Vehicle {
protected:
    string fuelType;
};

class Car : public Vehicle {
public:
    void setFuel(string type) {
        fuelType = type;  // 派生类可访问protected成员
    }
};

int main() {
    Car myCar;
    // myCar.fuelType = "Gasoline";  // 错误：类外不可访问
    myCar.setFuel("Diesel");  // 通过派生类方法修改
}
</syntaxhighlight>

== 实际应用案例 ==
'''用户认证系统'''的典型实现：

<syntaxhighlight lang="cpp">
class User {
private:
    string hashedPassword;  // 敏感数据私有化

protected:
    int accessLevel;  // 子类需要但外部不应直接修改

public:
    string username;
    bool verifyPassword(string input) {
        return hash(input) == hashedPassword;
    }
};

class Admin : public User {
public:
    Admin() { accessLevel = 3; }  // 派生类设置保护成员
};
</syntaxhighlight>

== 特殊注意事项 ==
* '''类默认访问权限'''：class默认为private，struct默认为public
* '''友元例外'''：friend声明可以突破访问限制
* '''继承类型影响'''：
  * 公有继承：基类访问权限不变
  * 保护继承：基类public→protected
  * 私有继承：所有基类成员→private

== 最佳实践 ==
1. 遵循'''最小暴露原则'''：默认使用private，仅暴露必要接口
2. 保护成员谨慎使用：仅当确定需要被继承时使用
3. 数据成员通常设为private，通过getter/setter控制访问
4. 保持接口（public方法）稳定，内部实现（private）可自由修改

== 数学表示 ==
访问控制可以形式化为可见性函数：
<math>
V(m, c) = \begin{cases} 
\text{true} & \text{if } m \in \text{public}(c) \\
\text{true} & \text{if } m \in \text{protected}(c) \land \text{isDerived}(c) \\
\text{true} & \text{if } m \in \text{private}(c) \land \text{isSameClass}(c) \\
\text{false} & \text{otherwise}
\end{cases}
</math>

其中：
* <math>m</math> = 类成员
* <math>c</math> = 访问上下文
* <math>\text{isDerived}</math> = 派生类检查
* <math>\text{isSameClass}</math> = 同类检查

[[Category:编程语言]]
[[Category:C++]]
[[Category:C++ 面向对象基础]]