C++ 类访问权限与三大特性详解

一、C++ 类三大访问权限 + 实例 + 设计目的

1. 三种访问修饰符

public 公有的
private 私有的
protected 保护的

2. 权限规则 + 代码示例

cpp 复制代码

#include <iostream>
using namespace std;

class Person
{
// 公有：任何地方都能访问
public:
    string name;
    void showInfo()
    {
        cout << name << " " << age << endl;
    }

// 私有：仅本类内部能访问，子类、外部都不行
private:
    int age;

// 保护：本类 + 子类可以访问，外部不行
protected:
    string addr;
};

（1）public 公有

范围：类内、类外、子类全都能访问
用途：对外暴露接口、成员变量
例子：上面 name、showInfo\(\)

cpp 复制代码

int main()
{
    Person p;
    p.name = "张三";      // ✅ 可行 public
    p.showInfo();        // ✅ 可行
    return 0;
}

（2）private 私有（最常用）

范围：只能当前类内部函数访问
子类不能访问，外部不能访问
例子：int age;

cpp 复制代码

int main()
{
    Person p;
    p.age = 20; // ❌ 编译报错，私有外部不可访问
}

（3）protected 保护

范围：
1. 本类内部可以访问
2. 派生类（子类）可以访问
3. 外部普通对象不能访问
专门为继承设计

cpp 复制代码

// 子类
class Student : public Person
{
public:
    void setData()
    {
        name = "李四";    // public ✅
        addr = "北京";    // protected ✅ 子类能用
        // age = 18;     // private ❌ 子类也用不了
    }
};

3. 为什么 C++ 要设计三种访问权限？核心目的

实现封装，控制数据读写

把敏感数据设为private，不让外部随意篡改，只能通过公有函数修改，统一校验。
区分内外接口
- 对外提供public接口使用
- 内部逻辑、成员隐藏在private
给继承留权限梯度
protected专门用来：父类预留成员给子类复用，又不让外部乱改。
降低耦合、提高代码安全性

防止外部随意修改类内部状态，减少 bug。

总结设计思想 ：最少权限原则------ 能私绝不公，能保护绝不公开。

二、C++ 三大特性：封装、继承、多态（通俗透彻版）

1. 封装（Encapsulation）

通俗理解

把数据和行为打包成一个整体，隐藏内部细节，只暴露可用接口。

两层含义

打包：属性 + 成员函数放进同一个类
隐藏：私有成员藏起来，外部只能通过公有函数操作

举例子

人：姓名、年龄（数据）；吃饭、走路（行为）

年龄设为private不让随便改
提供setAge\(int a\)统一设置，里面加判断：年龄不能负数

cpp 复制代码

private:
    int age;
public:
    void setAge(int a)
    {
        if(a > 0) age = a;
    }

封装好处

数据安全，防非法修改
代码内聚，结构清晰
内部修改不影响外部调用

2. 继承（Inheritance）

通俗理解

子类直接拿走父类所有可用成员，实现代码复用。

一句话：子承父业，不用重复写代码

结构

cpp 复制代码

// 父类
class Animal
{
public:
    void eat(){ cout << "吃东西" << endl; }
};

// 子类继承父类
class Dog : public Animal
{
public:
    void bark(){ cout << "汪汪叫" << endl; }
};

Dog 自动拥有 eat ()，自己只需要写独有方法。

继承三种方式

public 公有继承（最常用）
- 父 public→子 public
- 父 protected→子 protected
protected 保护继承
private 私有继承

继承意义

大量复用代码，减少冗余
快速扩展子类
建立类与类之间层级关系

3. 多态（Polymorphism）面试重中之重

通俗理解

同一个行为，不同对象表现出不同形态。

一句话：一个接口，多种实现

实现条件（必考 4 条）

必须存在继承关系
子类 \\ 重写（覆盖）\\ 父类虚函数
父类指针 / 引用指向子类对象
父类函数加 virtual 关键字

最简代码演示

cpp 复制代码

#include <iostream>
using namespace std;

class Animal
{
public:
    // 虚函数
    virtual void speak()
    {
        cout << "动物发声" << endl;
    }
};

class Cat : public Animal
{
public:
    // 重写虚函数
    void speak() override
    {
        cout << "喵喵喵" << endl;
    }
};

class Dog : public Animal
{
public:
    void speak() override
    {
        cout << "汪汪汪" << endl;
    }
};

int main()
{
    Animal *p1 = new Cat;
    Animal *p2 = new Dog;

    p1->speak(); // 喵喵喵
    p2->speak(); // 汪汪汪
    return 0;
}

同样调用 speak ()，对象不同结果不同 = 多态

多态分类

静态多态（编译期）：函数重载、运算符重载
动态多态（运行期）：虚函数实现，项目主力

多态作用

程序扩展性极强，新增子类不用改原有业务代码
面向接口编程，代码解耦
智驾、框架、底层库大量依赖多态

三、三者整体关系总结（面试背诵版）

封装：把东西包起来，管好内部数据，定好对外规矩
继承：代码复用，搭建类层次结构
多态：在继承基础上，实现统一接口、不同行为

最简口诀

封装藏细节，继承省代码，多态变行为。

（注：文档部分内容可能由 AI 生成）