C++ 类基础：封装、继承、多态与多线程模板实现

news2025/6/10 12:41:23

前言

C++ 是一门强大的面向对象编程语言，而类（Class）作为其核心特性之一，是理解和使用 C++ 的关键。本文将深入探讨 C++ 类的基本特性，包括封装、继承和多态，同时讨论类中的权限控制，并展示如何使用类继承实现一个简单的多线程开发模板。

类的基本特性

封装（Encapsulation）

封装是面向对象编程的基本原则之一，它指的是将数据（属性）和操作数据的方法（行为）捆绑在一起，形成一个独立的单元（即类），并隐藏对象的内部实现细节，只对外提供必要的接口。

在 C++ 中，封装通过类的定义来实现。类中的成员变量通常被声明为私有（private），而成员函数则根据需要声明为公有（public）或保护（protected）。外部代码只能通过公有成员函数来访问和修改类的私有成员变量，从而保证了数据的安全性和完整性。

class Rectangle {
private:
    double width;
    double height;

public:
    // 构造函数
    Rectangle(double w, double h) : width(w), height(h) {}

    // 公有成员函数，用于设置和获取宽度
    void setWidth(double w) { width = w; }
    double getWidth() const { return width; }

    // 公有成员函数，用于设置和获取高度
    void setHeight(double h) { height = h; }
    double getHeight() const { return height; }

    // 公有成员函数，计算面积
    double area() const { return width * height; }
};

继承（Inheritance）

继承允许一个类（子类或派生类）继承另一个类（父类或基类）的属性和方法。这有助于代码的重用和扩展，减少了重复代码的编写。

在 C++ 中，继承通过在派生类定义中使用冒号（:）后跟基类名来实现。派生类可以继承基类的公有和保护成员，但不能直接继承私有成员（除非通过基类的公有或保护成员函数访问）。

// 基类
class Shape {
protected:
    std::string color;

public:
    Shape(const std::string& c) : color(c) {}

    void setColor(const std::string& c) { color = c; }
    std::string getColor() const { return color; }
};

// 派生类
class Circle : public Shape {
private:
    double radius;

public:
    Circle(const std::string& c, double r) : Shape(c), radius(r) {}

    double area() const { return 3.14159 * radius * radius; }
};

多态（Polymorphism）

多态是指同一个接口或方法可以根据对象的不同类型执行不同的操作。在 C++ 中，多态主要通过虚函数（Virtual Functions）和继承来实现。

虚函数允许在派生类中重写基类中的函数，当通过基类指针或引用调用虚函数时，会根据对象的实际类型调用相应的派生类函数。

class Animal {
public:
    virtual void makeSound() const { std::cout << "Animal sound" << std::endl; }
};

class Dog : public Animal {
public:
    void makeSound() const override { std::cout << "Bark" << std::endl; }
};

class Cat : public Animal {
public:
    void makeSound() const override { std::cout << "Meow" << std::endl; }
};

void animalSound(const Animal& animal) {
    animal.makeSound(); // 根据实际类型调用相应的函数
}

类中的权限问题

在 C++ 类中，成员的访问权限由关键字 private、protected 和 public 控制：

private：私有成员只能在类的内部访问，外部代码无法直接访问。
protected：保护成员可以在类的内部和派生类中访问，但不能在类的外部直接访问。
public：公有成员可以在类的内部、派生类和类的外部直接访问。

合理使用这些权限关键字可以有效地控制类的接口和实现，提高代码的安全性和可维护性。

使用类继承实现多线程开发模板

下面是一个简单的多线程开发模板，使用类继承的方式实现。这个模板利用了 C++11 引入的 <thread> 库，通过定义一个基类 ThreadBase 和派生类来实现具体的线程任务。

#include <iostream>
#include <thread>
#include <vector>
#include <memory>

// 线程基类
class ThreadBase {
public:
    virtual ~ThreadBase() = default;

    // 启动线程
    void start() {
        thread_ = std::make_unique<std::thread>(&ThreadBase::run, this);
    }

    // 等待线程结束
    void join() {
        if (thread_ && thread_->joinable()) {
            thread_->join();
        }
    }

protected:
    // 纯虚函数，由派生类实现具体的线程任务
    virtual void run() = 0;

private:
    std::unique_ptr<std::thread> thread_;
};

// 派生类，实现具体的线程任务
class MyThread : public ThreadBase {
protected:
    void run() override {
        for (int i = 0; i < 5; ++i) {
            std::cout << "Thread running: " << i << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(500));
        }
    }
};

int main() {
    MyThread thread;
    thread.start();
    thread.join();

    return 0;
}

代码说明

ThreadBase 类：
- 定义了一个纯虚函数 run()，要求派生类必须实现。
- 提供了 start() 和 join() 方法，用于启动和等待线程结束。
- 使用 std::unique_ptr 管理 std::thread 对象，确保线程资源的安全释放。
MyThread 类：
- 继承自 ThreadBase，并实现了 run() 方法。
- 在 run() 方法中，打印线程运行状态并休眠一段时间，模拟线程任务。
main 函数：
- 创建 MyThread 对象，调用 start() 启动线程，然后调用 join() 等待线程结束。