5.C++面向对象

目录

• C++面向对象
  • 1.封装
    • 特点
    • 示例：
  • 2.继承
    • 特点
    • 继承方式
    • 示例：
  • 3. 多态（Polymorphism）
    • 特点
    • 示例（运行时多态）
  • 4. 抽象（Abstraction）
    • 特点
    • 示例
  • 5. 其他面向对象特性
    • (1) 构造函数 & 析构函数
    • (2) 运算符重载（Operator Overloading）
    • (3) 友元（Friend）

C++面向对象

面向对象核心特性包括 封装（Encapsulation）、继承（Inheritance）、多态（Polymorphism） 三大特性，以及 抽象（Abstraction）。

1.封装

将 数据（成员变量） 和 操作数据的方法（成员函数） 捆绑在一起，形成一个 类（Class），并 控制外部访问权限（通过 public、private、protected）

访问修饰符访问控制

访问修饰符	作用域
public	1.在任何地方都可以访问 2.通常用于类的接口部分
protected	1.在类内部和派生类中可以访问 2.对外部代码不可见 3.用于实现继承时的特殊访问控制
private	1.只能在类内部访问 2.默认访问级别（如果不指定修饰符） 3.通常用于隐藏实现细节

特点

• 数据隐藏：通过 private 限制外部直接访问数据，只能通过 public 方法操作。
• 提高安全性：防止数据被意外修改。
• 代码模块化：类是一个独立的模块，便于维护。

示例：

class Person {
private:
    string name;  // 私有成员，外部无法直接访问
    int age;

public:
    // 公有方法，用于访问私有成员
    void setName(string n) { name = n; }
    string getName() { return name; }

    void setAge(int a) { 
        if (a > 0) age = a;  // 可以添加逻辑验证
    }
    int getAge() { return age; }
};

int main() {
    Person p;
    p.setName("Alice");  // 通过公有方法访问私有成员
    p.setAge(25);
    cout << p.getName() << " is " << p.getAge() << " years old." << endl;
    return 0;
}

2.继承

允许一个类（派生类/子类）继承另一个类（基类/父类）的 成员变量和方法，并可以 扩展或修改 其功能。

特点

• 代码复用：子类可以复用父类的代码。
• 层次化设计：可以建立类之间的层次关系（如 Animal → Dog）。
• 支持多继承（C++ 特有，但一般不推荐使用）。

继承方式

继承方式	说明
public	父类的 public → 子类 public，protected → protected
protected	父类的 public 和 protected → 子类 protected
private	父类的 public 和 protected → 子类 private（默认方式，较少用）

示例：

class Animal {  // 基类
public:
    void eat() { cout << "Animal is eating." << endl; }
};

class Dog : public Animal {  // 派生类（公有继承）
public:
    void bark() { cout << "Dog is barking." << endl; }
};

int main() {
    Dog d;
    d.eat();   // 继承自 Animal
    d.bark();  // Dog 自己的方法
    return 0;
}

3. 多态（Polymorphism）

概念：同一操作作用于不同的对象，可以有不同的行为。C++ 主要通过 虚函数（Virtual Function） 和 函数重写（Override） 实现。

特点

• 运行时多态（动态绑定）：通过 虚函数 + 指针/引用 实现。
• 编译时多态（静态绑定）：通过 函数重载（Overload） 和 模板（Template） 实现。

示例（运行时多态）

class Shape {
public:
    virtual void draw() {  // 虚函数
        cout << "Drawing a shape." << endl;
    }
};

class Circle : public Shape {
public:
    void draw() override {  // 重写虚函数
        cout << "Drawing a circle." << endl;
    }
};

int main() {
    Shape* s = new Circle();  // 基类指针指向派生类对象
    s->draw();  // 输出 "Drawing a circle."（多态）
    delete s;
    return 0;
}

4. 抽象（Abstraction）

概念：仅暴露必要的接口，隐藏实现细节。在 C++ 中，可以通过 抽象类（Abstract Class） 和 纯虚函数（Pure Virtual Function） 实现。

特点

• 不能实例化：抽象类只能被继承，不能直接创建对象。
• 强制派生类实现：纯虚函数必须在派生类中重写。

示例

class AbstractAnimal {
public:
    virtual void makeSound() = 0;  // 纯虚函数
};

class Cat : public AbstractAnimal {
public:
    void makeSound() override {  // 必须实现
        cout << "Meow!" << endl;
    }
};

int main() {
    // AbstractAnimal a;  // 错误！不能实例化抽象类
    Cat c;
    c.makeSound();  // 输出 "Meow!"
    return 0;
}

5. 其他面向对象特性

(1) 构造函数 & 析构函数

• 构造函数：初始化对象（ClassName()）。
• 析构函数：清理资源（~ClassName()）。
• 拷贝构造函数：用于对象复制（ClassName(const ClassName& obj)）。

(2) 运算符重载（Operator Overloading）

class Vector {
public:
    int x, y;
    Vector operator+(const Vector& v) {  // 重载 + 运算符
        return Vector{x + v.x, y + v.y};
    }
};

(3) 友元（Friend）

允许 非成员函数或其他类 访问 private 成员（破坏封装，慎用）。

class Box {
private:
    int width;
    friend void printWidth(Box b);  // 友元函数
};
void printWidth(Box b) {
    cout << b.width;  // 可以访问私有成员
}