使用抽象类C++进行单独编译

在C++中，抽象类是一种特殊的类，它不能被实例化，只能作为基类来派生其他类。抽象类通常包含至少一个纯虚函数，纯虚函数是在基类中声明但不提供具体实现的虚函数，它的声明形式为 virtual void function() = 0;。

基础概念

抽象类：不能被实例化的类，用于定义接口。
纯虚函数：在基类中声明但不提供实现的虚函数，形式为 virtual void function() = 0;。
派生类：继承自抽象类的类，必须实现基类中的所有纯虚函数才能被实例化。

优势

接口定义：抽象类提供了一种定义接口的方式，强制派生类遵循特定的结构。
代码复用：可以在抽象类中实现一些通用的功能，减少代码重复。
多态性：通过基类指针或引用调用派生类的方法，实现运行时多态。

类型

完全抽象类：只包含纯虚函数的类。
部分抽象类：除了纯虚函数外，还包含一些具体实现的虚函数和非虚函数。

应用场景

框架设计：在设计大型软件框架时，抽象类用于定义核心组件和行为。
插件系统：允许第三方开发者实现特定接口，扩展软件功能。
图形用户界面（GUI）库：定义控件的基本行为和属性。

示例代码

以下是一个简单的C++抽象类及其派生类的例子：

// 抽象类 Shape
class Shape {
public:
    virtual double area() const = 0; // 纯虚函数
    virtual void draw() const = 0;   // 纯虚函数
    virtual ~Shape() {}              // 虚析构函数
};

// 派生类 Circle
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override {
        return 3.14159 * radius * radius;
    }
    void draw() const override {
        std::cout << "Drawing a circle." << std::endl;
    }
};

// 派生类 Square
class Square : public Shape {
private:
    double side;
public:
    Square(double s) : side(s) {}
    double area() const override {
        return side * side;
    }
    void draw() const override {
        std::cout << "Drawing a square." << std::endl;
    }
};

int main() {
    Shape* shapes[2];
    shapes[0] = new Circle(5);
    shapes[1] = new Square(4);

    for (int i = 0; i < 2; ++i) {
        shapes[i]->draw();
        std::cout << "Area: " << shapes[i]->area() << std::endl;
        delete shapes[i];
    }

    return 0;
}

单独编译

在C++中，单独编译是指将程序的不同部分分别编译成目标文件，然后链接成一个可执行文件。这可以通过以下步骤实现：

编写源文件：将抽象类和派生类的定义分别放在不同的 .cpp 文件中。
编写头文件：为每个类创建一个 .h 头文件，包含类的声明。
编译源文件：使用编译器分别编译每个 .cpp 文件生成目标文件（.o 或 .obj）。
链接目标文件：使用链接器将所有目标文件链接成一个可执行文件。

例如，对于上面的例子，可以有以下文件结构：

shape.h
circle.h
square.h
shape.cpp
circle.cpp
square.cpp
main.cpp

编译命令可能如下：

g++ -c shape.cpp -o shape.o
g++ -c circle.cpp -o circle.o
g++ -c square.cpp -o square.o
g++ -c main.cpp -o main.o
g++ shape.o circle.o square.o main.o -o my_program