如何在C++中实现面向对象编程？

C++ 面向对象编程（OOP）的核心是 封装、继承、多态，通过 class 关键字定义类，将数据（成员变量）和操作（成员函数）绑定在一起，同时支持派生类扩展基类、虚函数实现动态行为。以下是具体实现方法和示例：

一、封装：将数据与行为绑定

封装是把对象的属性（数据）和方法（操作）隐藏在类内部，仅通过公共接口（public 成员函数）与外部交互，避免直接访问内部数据，保证数据安全性和代码可维护性。

实现步骤：

1. 用 class 定义类，区分访问权限：
   • public：外部可访问（接口）
   • private：仅类内部可访问（隐藏数据）
   • protected：类内部和派生类可访问（继承用）
2. 成员变量私有化，通过公共成员函数（getter/setter）访问和修改数据。

示例：封装一个 Person 类

cpp

 

运行

 

 

 

 

#include <iostream>
#include <string>
using namespace std;

class Person {
private:
    // 私有成员变量（隐藏数据）
    string name;
    int age;

public:
    // 公共接口（外部可访问）
    void setName(string n) {
        name = n; // 控制姓名赋值逻辑
    }
    void setAge(int a) {
        if (a > 0 && a < 120) { // 合法年龄校验
            age = a;
        } else {
            cout << "年龄不合法！" << endl;
        }
    }
    string getName() {
        return name;
    }
    int getAge() {
        return age;
    }
    void showInfo() {
        cout << "姓名：" << name << "，年龄：" << age << endl;
    }
};

int main() {
    Person p;
    p.setName("张三");
    p.setAge(25); // 合法年龄
    p.showInfo(); // 输出：姓名：张三，年龄：25

    p.setAge(150); // 非法年龄，提示错误
    return 0;
}

 

二、继承：扩展已有类的功能

继承允许创建一个新类（派生类），继承另一个类（基类）的属性和方法，同时可以添加新成员或重写基类成员，实现代码复用和扩展。

实现步骤：

1. 定义基类（父类），包含通用属性和方法。
2. 定义派生类时，通过 class 派生类名 : 继承方式 基类名 继承，继承方式：
   • public：基类 public 成员→派生类 public，protected 成员→派生类 protected（常用）
   • protected：基类 public/protected 成员→派生类 protected
   • private：基类 public/protected 成员→派生类 private
3. 派生类可访问基类 public/protected 成员，通过 基类名::成员 访问基类隐藏成员。

示例：继承 Person 类实现 Student 类

cpp

 

运行

 

 

 

 

// 基类：Person（同上）
class Student : public Person { // 公有继承 Person
private:
    string studentID; // 派生类新增成员
    double score;

public:
    // 派生类构造函数（需初始化基类）
    Student(string n, int a, string id, double s) {
        setName(n); // 调用基类 public 方法
        setAge(a);
        studentID = id;
        score = s;
    }

    // 派生类新增方法
    void showStudentInfo() {
        showInfo(); // 调用基类方法
        cout << "学号：" << studentID << "，成绩：" << score << endl;
    }

    // 重写基类方法（可选）
    void showInfo() {
        cout << "学生姓名：" << getName() << "，年龄：" << getAge() << endl;
    }
};

int main() {
    Student s("李四", 20, "2023001", 95.5);
    s.showStudentInfo(); 
    // 输出：
    // 学生姓名：李四，年龄：20
    // 学号：2023001，成绩：95.5
    return 0;
}

 

三、多态：同一接口实现不同行为

多态是指同一方法（或操作）作用于不同对象时，产生不同的执行结果。C++ 主要通过 虚函数（virtual） 和 纯虚函数（抽象类） 实现。

1. 虚函数（动态多态）

• 基类中用 virtual 声明成员函数，派生类重写该函数（函数名、参数、返回值一致）。
• 当基类指针 / 引用指向派生类对象时，调用虚函数会自动匹配派生类的实现（动态绑定）。

2. 纯虚函数与抽象类

• 纯虚函数：基类中声明时赋值为 0 的虚函数（virtual 返回类型 函数名(参数) = 0;），无具体实现。
• 抽象类：包含纯虚函数的类，不能实例化，仅用于被继承，派生类必须重写所有纯虚函数才能实例化。

示例：虚函数实现多态

cpp

 

运行

 

 

 

 

class Shape { // 抽象类（含纯虚函数）
public:
    virtual double getArea() = 0; // 纯虚函数：计算面积
    virtual void showShape() { // 普通虚函数
        cout << "这是一个图形" << endl;
    }
};

class Circle : public Shape { // 圆类（继承抽象类）
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    // 重写纯虚函数
    double getArea() override {
        return 3.14 * radius * radius;
    }

    // 重写普通虚函数
    void showShape() override {
        cout << "这是一个圆，半径：" << radius << endl;
    }
};

class Rectangle : public Shape { // 矩形类
private:
    double width, height;

public:
    Rectangle(double w, double h) : width(w), height(h) {}

    double getArea() override {
        return width * height;
    }

    void showShape() override {
        cout << "这是一个矩形，宽：" << width << "，高：" << height << endl;
    }
};

int main() {
    Shape* shape1 = new Circle(5); // 基类指针指向派生类对象
    Shape* shape2 = new Rectangle(4, 6);

    shape1->showShape(); // 输出：这是一个圆，半径：5
    cout << "面积：" << shape1->getArea() << endl; // 输出：78.5

    shape2->showShape(); // 输出：这是一个矩形，宽：4，高：6
    cout << "面积：" << shape2->getArea() << endl; // 输出：24

    delete shape1;
    delete shape2;
    return 0;
}

 

四、OOP 核心补充：构造函数、析构函数与拷贝控制

1. 构造函数

• 用于对象初始化，与类名同名，无返回值，可重载（多个构造函数参数不同）。
• 派生类构造函数需先初始化基类，通过初始化列表（派生类构造函数(参数) : 基类构造函数(参数)）实现。

2. 析构函数

• 用于释放对象资源（如动态内存），格式：~类名()，无参数，不可重载。
• 基类析构函数必须声明为 virtual，否则派生类对象销毁时可能不调用派生类析构函数，导致内存泄漏。

示例：构造函数、析构函数与虚析构

cpp

 

运行

 

 

 

 

class Base {
public:
    Base() { cout << "Base 构造函数" << endl; }
    virtual ~Base() { cout << "Base 析构函数" << endl; } // 虚析构
};

class Derived : public Base {
private:
    int* data;

public:
    Derived(int x) {
        data = new int(x); // 动态分配内存
        cout << "Derived 构造函数" << endl;
    }

    ~Derived() override {
        delete data; // 释放内存
        cout << "Derived 析构函数" << endl;
    }
};

int main() {
    Base* obj = new Derived(10); // 基类指针指向派生类对象
    delete obj; // 调用 Derived 析构 + Base 析构（虚析构生效）
    return 0;
}

 

五、OOP 关键原则

1. 单一职责：一个类只负责一项功能（如 Person 只管理个人信息，不负责学生成绩）。
2. 开放封闭：对扩展开放（可通过继承新增功能），对修改封闭（不修改原有类代码）。
3. 里氏替换：派生类对象可替换基类对象，且不影响程序正确性（如 Student 可替代 Person 调用 showInfo）。
4. 依赖倒置：依赖抽象类（如 Shape），不依赖具体类（如 Circle），降低耦合。

通过以上特性，C++ 可以灵活实现面向对象编程，构建模块化、可复用、易维护的代码结构。