8.5 纯虚函数和抽象类

 

8.5 纯虚函数和抽象类

8.5.1 纯虚函数

纯虚函数是在类体中不提供具体实现的虚函数。其一般格式如下：

virtual <返回类型> <函数名>(<参数表>) = 0;

在许多情况下，基类中的虚函数不需要提供具体实现，而是将其声明为纯虚函数，并将实现留给派生类去完成。

示例：使用纯虚函数

以下是一个使用纯虚函数的例子：

#include <iostream>
using namespace std;

class Point {
public:
    Point(int i = 0, int j = 0) : x(i), y(j) {}
    virtual void set() = 0;
    virtual void draw() = 0;

protected:
    int x, y;
};

class Line : public Point {
public:
    Line(int i = 0, int j = 0, int m = 0, int n = 1) : Point(i, j), x1(m), y1(n) {}
    void set() override {
        cout << "Line::set() called." << endl;
    }
    void draw() override {
        cout << "Line::draw() called." << endl;
    }

protected:
    int x1, y1;
};

class Ellipse : public Point {
public:
    Ellipse(int i = 0, int j = 0, int p = 0, int q = 1) : Point(i, j), x2(p), y2(q) {}
    void set() override {
        cout << "Ellipse::set() called." << endl;
    }
    void draw() override {
        cout << "Ellipse::draw() called." << endl;
    }

protected:
    int x2, y2;
};

void drawObj(Point *p) {
    p->draw();
}

void setObj(Point *p) {
    p->set();
}

int main() {
    Line *lineObj = new Line;
    Ellipse *ellipseObj = new Ellipse;

    drawObj(lineObj);
    drawObj(ellipseObj);
    cout << endl;
    setObj(lineObj);
    setObj(ellipseObj);
    cout << "\nRedraw the objects...\n";
    drawObj(lineObj);
    drawObj(ellipseObj);

    delete lineObj;
    delete ellipseObj;

    return 0;
}

说明

在这个程序中，Point 类中声明了两个纯虚函数 set() 和 draw()。Line 和 Ellipse 这两个派生类分别实现了这些虚函数。drawObj() 和 setObj() 函数的参数是指向 Point 类的指针，这实现了动态联编，程序在运行时选择相应的函数实现。

8.5.2 抽象类

带有纯虚函数的类称为抽象类。抽象类是一种特殊的类，它是为了抽象和设计的目的而建立的，处于继承层次结构的上层。抽象类不能实例化对象，但可以定义对象指针和对象引用。

抽象类的作用

抽象类的主要作用是将有关的类组织在一个继承层次的结构中，为它们提供一个公共的根。抽象类刻画了一组子类的操作接口的通用语义，这些语义也传给子类。一般而言，抽象类只描述这组子类共同的操作接口，而将具体实现留给子类。

示例：抽象类

以下是一个关于抽象类的例子，采用变步长辛普森算法计算积分：

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

class F {
public:
    virtual double operator()(double x) const = 0;
};

class Integral {
public:
    virtual double operator()(double a, double b, double eps) const = 0;
};

class Simpson : public Integral {
public:
    Simpson(const F& ff) : f(ff) {}
    double operator()(double a, double b, double eps) const override;

private:
    const F& f;
};

double Simpson::operator()(double a, double b, double eps) const {
    int done = 0;
    int n = 1;
    double h = b - a;
    double Tn = h * (f(a) + f(b)) / 2.0;
    double In = Tn;

    while (!done) {
        double temp = 0.0;
        for (int k = 0; k < n; ++k) {
            double x = a + (k + 0.5) * h;
            temp += f(x);
        }
        double T2n = (Tn + h * temp) / 2.0;
        double I2n = (4.0 * T2n - Tn) / 3.0;

        if (fabs(I2n - In) < eps) {
            done = 1;
        } else {
            Tn = T2n;
            n *= 2;
            h /= 2;
            In = I2n;
        }
    }
    return In;
}

class Function : public F {
public:
    double operator()(double x) const override {
        return log(1.0 + x) / (1.0 + x * x);
    }
};

int main() {
    Function f;
    Simpson simp(f);
    cout << simp(0, 2, 1E-7) << endl;
    return 0;
}

说明

该程序中有两个抽象类，分别是 F 和 Integral。Function 和 Simpson 类分别继承了这些抽象类，并实现了纯虚函数。Function 类实现了函数的计算逻辑，而 Simpson 类实现了积分计算逻辑。

结论

纯虚函数和抽象类是C++中实现面向对象编程的重要工具。通过纯虚函数，基类可以定义接口，而将具体实现留给派生类。这种机制提供了很大的灵活性和扩展性。抽象类通过定义一组共同的操作接口，组织相关的类，并提供一个公共的继承层次，为面向对象设计提供了强有力的支持。希望本文对纯虚函数和抽象类的理解有所帮助，为编写更灵活、更易维护的C++程序提供支持。