C++学习系列（6）：面向对象编程（OOP）

最新推荐文章于 2025-11-04 20:03:25 发布

原创最新推荐文章于 2025-11-04 20:03:25 发布 · 830 阅读

18 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #学习

C++学习系列专栏收录该内容

15 篇文章

订阅专栏

C++学习系列（6）：面向对象编程（OOP）

1. 引言

在 C++ 之前的学习中，我们介绍了 基本数据类型、数组、指针、字符串、结构体 等基础内容。
但是，C++ 作为一门 面向对象编程（Object-Oriented Programming, OOP） 语言，其核心思想是 “万物皆对象”。

本篇博客，我们将深入探讨：

类与对象（C++ 的核心）
构造函数和析构函数
封装、继承、多态
对象的内存分配

2. C++ 类与对象

2.1 什么是类和对象？

类（Class）：抽象的概念，类似于模板，定义了对象的行为和属性。
对象（Object）：类的实例，具体的数据实体。

2.2 定义和使用类

在 C++ 中，类的定义通常如下：

#include <iostream>

class Person {
public:
    std::string name;
    int age;

    void introduce() {
        std::cout << "姓名: " << name << ", 年龄: " << age << std::endl;
    }
};

int main() {
    Person p1;
    p1.name = "张三";
    p1.age = 20;
    p1.introduce();

    return 0;
}

📌 代码解析

class Person 定义了 Person 类。
name 和 age 是 成员变量（属性）。
introduce() 是 成员函数（方法）。
p1 是 Person 类的对象。

3. 构造函数和析构函数

3.1 构造函数

构造函数用于对象初始化，特点：

函数名和类名相同。
无返回值。
可定义多个（重载）。

#include <iostream>

class Person {
public:
    std::string name;
    int age;

    // 构造函数
    Person(std::string n, int a) {
        name = n;
        age = a;
    }

    void introduce() {
        std::cout << "姓名: " << name << ", 年龄: " << age << std::endl;
    }
};

int main() {
    Person p1("李四", 25);
    p1.introduce();

    return 0;
}

📌 构造函数的作用

在创建对象时，自动调用，不需要手动执行。
用于对象的初始化。

3.2 析构函数

析构函数用于对象销毁时的清理工作：

函数名是 ~类名()
无参数、无返回值
对象销毁时自动执行

#include <iostream>

class Person {
public:
    std::string name;

    // 构造函数
    Person(std::string n) {
        name = n;
        std::cout << name << " 创建成功！" << std::endl;
    }

    // 析构函数
    ~Person() {
        std::cout << name << " 被销毁！" << std::endl;
    }
};

int main() {
    Person p1("张三");
    return 0;
}

📌 析构函数的作用

释放资源（如动态内存、文件、数据库连接）。
对象生命周期结束时自动调用。

4. 封装、继承、多态（OOP 三大特性）

4.1 封装（Encapsulation）

封装指的是数据隐藏和保护：

private：类内部可访问，外部不可访问。
public：类内外均可访问。

#include <iostream>

class BankAccount {
private:
    double balance;

public:
    BankAccount(double b) {
        balance = b;
    }

    void deposit(double amount) {
        balance += amount;
    }

    double getBalance() {
        return balance;
    }
};

int main() {
    BankAccount account(1000);
    account.deposit(500);
    std::cout << "余额: " << account.getBalance() << std::endl;
    return 0;
}

📌 封装的好处

防止误操作，保证数据安全。
隐藏实现细节，提高代码可维护性。

4.2 继承（Inheritance）

继承是类之间的关系，子类继承父类的属性和方法。

#include <iostream>

class Animal {
public:
    void speak() {
        std::cout << "动物在叫！" << std::endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        std::cout << "狗在汪汪叫！" << std::endl;
    }
};

int main() {
    Dog d;
    d.speak();  // 继承自 Animal
    d.bark();   // Dog 自己的方法

    return 0;
}

📌 继承的优点

代码复用，减少重复代码。
提高扩展性。

4.3 多态（Polymorphism）

多态指的是同一个接口，多个实现，通常通过 虚函数（virtual） 实现。

#include <iostream>

class Animal {
public:
    virtual void speak() {  // 关键字 virtual
        std::cout << "动物在叫！" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "狗在汪汪叫！" << std::endl;
    }
};

int main() {
    Animal* a = new Dog();
    a->speak();  // 调用 Dog 的方法，而不是 Animal 的

    delete a;
    return 0;
}

📌 多态的特点

基类指针指向子类对象。
调用的是子类的方法（动态绑定）。
必须使用 virtual 关键字。

5. 类的内存分配

5.1 栈上创建对象

Person p1("张三");

📌 对象生命周期

自动管理，无需手动释放。
代码块结束后，自动销毁。

5.2 堆上创建对象

Person* p2 = new Person("李四");
delete p2;

📌 对象生命周期

需要手动释放（delete），否则会内存泄漏。
适用于动态管理对象。

6. 总结

本篇博客，我们学习了 C++ 面向对象编程（OOP）：
✅ 类与对象
✅ 构造函数 & 析构函数
✅ 封装、继承、多态
✅ 对象的内存分配

🎯 OOP 是 C++ 高级编程 的基础，为后续学习 STL、智能指针、模板编程 奠定基础。

在下一篇 C++学习系列（7） 中，我们将学习 C++的运算符重载，敬请期待！🚀

💡 如果你喜欢这篇文章，欢迎点赞、收藏，并关注本系列！