C++纯虚函数和抽象类

提示信息

残樱落红

10月09日发表在 c++编程语言阅读 280 评论 20 | 免费使用 “AI大模型GPT4.0” 提问

C++中的纯虚函数和抽象类是面向对象编程的概念，用于定义接口和实现多态性。

纯虚函数：
纯虚函数是指在基类中只声明而没有定义的虚函数。它没有函数体，只起到接口的作用，子类必须实现这个函数才能实例化。纯虚函数通过在函数声明后面加上 "= 0" 来指定，例如：

class Base {  
public:  
    virtual void foo() = 0; // 纯虚函数  
};  
class Derived : public Base {  
public:  
    void foo() {  
        // 子类实现虚函数  
    }  
};

注意，包含纯虚函数的类是抽象类，不能直接实例化。

抽象类：
抽象类是指包含至少一个纯虚函数的类，无法直接实例化。抽象类通过纯虚函数定义了接口，子类必须实现这些接口才能实例化。抽象类可以有非纯虚函数和数据成员，但是只要包含了纯虚函数，它就是抽象类。例如：

class AbstractClass {  
public:  
    virtual void foo() = 0; // 纯虚函数  
    void bar() {  
        // 包含非纯虚函数  
    }  
};  
class ConcreteClass : public AbstractClass {  
public:  
    void foo() {  
        // 子类实现纯虚函数  
    }  
};

在上述示例中，AbstractClass是一个抽象类，它包含一个纯虚函数foo()和一个非纯虚函数bar()，而ConcreteClass是AbstractClass的一个具体实现。

使用纯虚函数和抽象类可以实现多态性，即通过基类的指针或引用调用派生类的方法。这样可以提高代码的灵活性和可复用性。

遇到难题？ "AI大模型GPT4.0、GPT" 是你的私人解答专家！点击按钮去提问......

残樱落红赞 | 0

最近一次登录：2023-10-09 11:47:42

暂时还没有签名，请关注我或评论我的文章

20条评论

按时间正序按时间倒序按喜欢排序

失忆

10月12日

对于初学者，文中的解释很到位，让人很容易理解纯虚函数和抽象类的概念。

赞 0 回复举报

从未： @失忆

对于纯虚函数和抽象类的理解，可以通过一些简单的代码示例进一步加深印象。例如，考虑一个表示形状的抽象类，其中定义了一个纯虚函数用于计算面积：

class Shape {
public:
    virtual double area() const = 0; // 纯虚函数
};

class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    double area() const override {
        return 3.14159 * radius * radius;
    }
};

class Rectangle : public Shape {
private:
    double width, height;
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    double area() const override {
        return width * height;
    }
};

在这个例子中，Shape类是一个抽象类，定义了一个纯虚函数area()，它要求所有派生类必须实现此函数。这种设计使得可以创建多种形状，每种形状都有自己的面积计算方式，体现了多态性。

对于深入学习抽象类的概念，建议查看一些相关的资源，比如 C++ Reference。这样可以获取更全面的信息，帮助更好地理解这一重要的面向对象编程特性。

3天前回复举报

添加新评论

梦回中

10月14日

代码示例清晰明了，展示了如何定义和实现纯虚函数和抽象类。实际上，可以借鉴这些方法来构建灵活的工程代码。

赞 0 回复举报

-▲　褪色： @梦回中

对于抽象类和纯虚函数的讨论，不妨进一步探讨如何在实际项目中应用这些概念来提高代码的灵活性。例如，在设计一个图形程序时，可以定义一个抽象基类 Shape，其中包含一个纯虚函数 draw。不同的形状类（如 Circle 和 Rectangle）可以实现这个函数，从而各自提供特定的绘制逻辑。

#include <iostream>

class Shape {
public:
    virtual void draw() const = 0;  // 纯虚函数
};

class Circle : public Shape {
public:
    void draw() const override {
        std::cout << "绘制圆形" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() const override {
        std::cout << "绘制矩形" << std::endl;
    }
};

void renderShape(const Shape& shape) {
    shape.draw(); // 动态绑定
}

int main() {
    Circle circle;
    Rectangle rectangle;

    renderShape(circle);    // 输出: 绘制圆形
    renderShape(rectangle); // 输出: 绘制矩形

    return 0;
}

这样的设计模式不仅使得代码更加模块化，还增强了扩展性，只需添加新的形状类即可实现新的绘制方式，而无需修改现有的代码。

关于对此主题的深入理解，可以参考这篇文章：C++ Abstract Classes and Pure Virtual Functions。

4天前回复举报

添加新评论

淡忘如思

10月24日

将抽象类用于设计模式中的工厂方法、策略模式等，提高了系统的可扩展性和复用性。

赞 0 回复举报

令狐帅帅： @淡忘如思

在设计模式中，使用抽象类和纯虚函数确实能显著提高系统的扩展性和复用性。比如在工厂方法模式中，定义一个抽象的产品类，然后通过具体工厂类来实例化相应的产品，这种方法能够灵活地应对产品的新增，更改或替换。

以下是一个简单的示例，以工厂方法模式为例：

#include <iostream>

// 抽象产品类
class Product {
public:
    virtual void use() = 0; // 纯虚函数
};

// 具体产品类
class ConcreteProductA : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductA." << std::endl;
    }
};

class ConcreteProductB : public Product {
public:
    void use() override {
        std::cout << "Using ConcreteProductB." << std::endl;
    }
};

// 抽象工厂类
class Creator {
public:
    virtual Product* factoryMethod() = 0; // 纯虚函数
};

// 具体工厂类
class ConcreteCreatorA : public Creator {
public:
    Product* factoryMethod() override {
        return new ConcreteProductA();
    }
};

class ConcreteCreatorB : public Creator {
public:
    Product* factoryMethod() override {
        return new ConcreteProductB();
    }
};

int main() {
    Creator* creatorA = new ConcreteCreatorA();
    Product* productA = creatorA->factoryMethod();
    productA->use();

    Creator* creatorB = new ConcreteCreatorB();
    Product* productB = creatorB->factoryMethod();
    productB->use();

    delete productA;
    delete productB;
    delete creatorA;
    delete creatorB;

    return 0;
}

在这个示例中，通过抽象产品类和具体工厂类的组合，可以轻松扩展新的产品类型而无需修改现有代码，从而遵循开闭原则。推荐参考设计模式相关书籍，如《设计模式：可复用面向对象软件的基础》以深入理解这些概念。

11月14日回复举报

添加新评论

余辉

11月01日

很赞同文章中关于不能实例化抽象类的描述。更进一步，可以扩展到理解接口到底如何提高代码封装性和灵活性。

赞 0 回复举报

新不： @余辉

在抽象类和纯虚函数的讨论中，确实可以延伸到如何利用接口设计提升代码的封装性和灵活性。通过定义接口，可以实现多态性，允许不同的类实现相同的接口，从而使得代码更加灵活且易于维护。例如，以下是一个简单的实现：

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

class Circle : public Shape {
public:
    void draw() override {
        // 绘制圆形
        std::cout << "Drawing a Circle" << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        // 绘制正方形
        std::cout << "Drawing a Square" << std::endl;
    }
};

void renderShape(Shape& shape) {
    shape.draw();
}

在上述例子中，Shape 是一个抽象类，不能直接实例化，而 Circle 和 Square 则具体实现了 draw 函数。当调用 renderShape 函数时，可以轻松地传入任何形状，增强了代码的灵活性。这样，即便后续增加新形状，只需实现 Shape 接口而无需更改 renderShape 函数，符合开闭原则。

有关接口设计和抽象类的深入了解，推荐参考 C++ Interface Programming 以获得更详细的内容和示例。

6天前回复举报

添加新评论

禁夜

11月09日

还可以参考C++标准库中的一些抽象模式运用，具体例子可以看看C++参考手册。

赞 0 回复举报

心性： @禁夜

对于抽象类和纯虚函数，可以深入探讨它们在设计模式中的应用。例如，观察C++标准库中的迭代器接口，便是一个经典的抽象类示例。

下面是一个简单的代码示例，展示了抽象类和纯虚函数的用法：

#include <iostream>

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Circle" << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Square" << std::endl;
    }
};

int main() {
    Shape* shape1 = new Circle();
    Shape* shape2 = new Square();

    shape1->draw(); // 输出: Drawing a Circle
    shape2->draw(); // 输出: Drawing a Square

    delete shape1;
    delete shape2;
    return 0;
}

这种方法使得可以针对不同形状的对象调用相同的 draw 方法，而不需要了解具体的实现细节。此外，从C++标准库中可以见到相似的模式，例如 std::function 用作通用回调，提供了灵活的设计可能性。

进一步探讨这里涉及的设计原则，例如开闭原则（Open/Closed Principle），能有助于强化程序的可维护性和扩展性。想要了解更多这方面的内容，可以查看 C++ Inheritance Tutorial，深入理解继承和多态的魅力。

11月14日回复举报

添加新评论

羊羊

11月11日

利用接口类管理系统架构的确实是一种良好的编码习惯，这也增进新功能的增添和功能模块的重构。

赞 0 回复举报

空瓶： @羊羊

使用接口类管理系统架构是一种相对成熟的设计思路，它为系统的可维护性和可扩展性提供了良好的支持。通过设计抽象类，可以实现多态，使得后续扩展新的功能变得更加灵活。比如，可以定义一个抽象基类并继承实现具体的功能模块。

例如，考虑以下抽象类的定义：

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
    virtual double area() = 0; // 纯虚函数
};

然后可以根据需要实现不同的形状类：

class Circle : public Shape {
public:
    Circle(double r) : radius(r) {}
    void draw() override {
        // 实现绘制圆形的代码
    }
    double area() override {
        return 3.14 * radius * radius; // 返回圆的面积
    }
private:
    double radius;
};

class Rectangle : public Shape {
public:
    Rectangle(double w, double h) : width(w), height(h) {}
    void draw() override {
        // 实现绘制矩形的代码
    }
    double area() override {
        return width * height; // 返回矩形的面积
    }
private:
    double width;
    double height;
};

通过这样的设计，添加新形状只需实现Shape接口，并编写相关代码，无需修改现有代码，从而提高了系统的模块化程度。这样的思路在面临复杂系统时尤为重要。

如果想进一步了解关于抽象类和接口如何促进代码设计的内容，可以参考 C++ Programming Language 这本书，其中有详细的解释与实例。

3天前回复举报

添加新评论

沉世

11月16日

描述非常详尽，尤其是对于派生类必须实现基类中的纯虚函数这一点的强调，减少了编程中的错误发生。

赞 0 回复举报

小疯狂： @沉世

评论非常到位，纯虚函数和抽象类在C++中的确是设计的重要组成部分。合理使用纯虚函数不仅能够避免错误，还能提高代码的可维护性和灵活性。抽象类提供了一个清晰的接口，这对团队协作和未来的扩展都有很大帮助。

下面提供一个简单的示例，展示如何定义抽象类及其派生类，确保所有派生类都实现了基类中的纯虚函数：

#include <iostream>

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Circle" << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing Square" << std::endl;
    }
};

void renderShape(Shape& shape) {
    shape.draw();
}

int main() {
    Circle circle;
    Square square;

    renderShape(circle); // 输出: Drawing Circle
    renderShape(square); // 输出: Drawing Square

    return 0;
}

通过上述代码，可以看出每个派生类都必须实现draw()方法，这样可以确保从Shape派生的所有类都具有统一的行为。理解抽象类的设计理念，将有助于更好地进行面向对象的编程。

对于进一步了解C++中抽象类和多态的概念，可以参考这个链接：C++ Abstract Classes and Pure Virtual Functions。

前天回复举报

添加新评论

魅眸

11月23日

建议配合设计实践中的实用例子解释，使初学者能更好地将理论与实践相结合。

赞 0 回复举报

放肆： @魅眸

在讨论C++的纯虚函数和抽象类时，结合实际的设计模式和应用示例，确实可以有效地帮助理解这些概念。例如，可以通过工厂模式（Factory Pattern）来展示如何使用抽象类和纯虚函数，以实现灵活的对象创建。

以下是一个简单的示例，展示如何定义一个抽象类和实现其子类：

#include <iostream>
#include <memory>

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

// 子类实现
class Circle : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Circle." << std::endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        std::cout << "Drawing a Square." << std::endl;
    }
};

// 工厂函数
std::unique_ptr<Shape> createShape(const std::string& type) {
    if (type == "circle") return std::make_unique<Circle>();
    if (type == "square") return std::make_unique<Square>();
    return nullptr;
}

int main() {
    auto shape1 = createShape("circle");
    if (shape1) shape1->draw();

    auto shape2 = createShape("square");
    if (shape2) shape2->draw();

    return 0;
}

在这个例子中，Shape是一个抽象类，其中定义了一个纯虚函数draw()，子类Circle和Square实现了这个方法。通过工厂函数createShape，可以根据需求创建不同的形状对象。这种设计不仅提高了代码的可扩展性，还体现了面向对象编程的原则。

推荐参考设计模式相关的书籍，如《设计模式：可复用面向对象软件的基础》（Gang of Four），以进一步加深理解。

11月10日回复举报

添加新评论

韦曼棋

11月26日

没提到的是利用抽象类提升的代码一致性，通过这种方式，继承链条的统一性也能得到保证。

赞 0 回复举报

花开花落： @韦曼棋

利用抽象类来提高代码一致性确实是一个很重要的方面。比如，我们可以通过定义一个抽象基类来确保所有继承类都实现某些核心功能，这样可以减少代码中的重复性和错误。

下面是一个简单的代码示例，展示如何使用抽象类来提高一致性：

#include <iostream>

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

// 继承类
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}

    void draw() override {
        std::cout << "Drawing a Circle" << std::endl;
    }

    double area() override {
        return 3.14 * radius * radius; 
    }
};

class Square : public Shape {
private:
    double side;
public:
    Square(double s) : side(s) {}

    void draw() override {
        std::cout << "Drawing a Square" << std::endl;
    }

    double area() override {
        return side * side; 
    }
};

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;
    }

    // 清理内存
    for (int i = 0; i < 2; i++) {
        delete shapes[i];
    }

    return 0;
}

在这个示例中，Shape 作为一个抽象类定义了 draw 和 area 方法，确保所有派生类都实现这些方法。在使用这些派生类时，统一的接口保证了代码的一致性，同时也提升了代码的可维护性和可扩展性。如果未来需要添加新的形状，只需继承 Shape 类并实现其方法。

可以参考更多关于C++抽象类和纯虚函数的内容，例如 C++ Documentation 来深入了解这个主题。

5天前回复举报

添加新评论

西风断刀

12月04日

提供的内容全面而易于理解，如果有时间可以进一步探讨设计模式在多态性和继承中的作用。

赞 0 回复举报

雕琢： @西风断刀

文本内容：

对于C++中的纯虚函数和抽象类的理解，确实与设计模式密切相关。例如，工厂模式常常利用抽象类来定义产品的接口，从而实现灵活的对象创建。使用纯虚函数可以确保每个派生类都实现这些接口，使代码更加严谨。

下面是一个简单示例，展示如何利用抽象类和纯虚函数来实现多态：

#include <iostream>
using namespace std;

// 抽象类
class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

// 具体类
class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing Circle" << endl;
    }
};

class Square : public Shape {
public:
    void draw() override {
        cout << "Drawing Square" << endl;
    }
};

void renderShape(Shape& shape) {
    shape.draw(); // 多态性
}

int main() {
    Circle circle;
    Square square;

    renderShape(circle);
    renderShape(square);

    return 0;
}

在这个示例中，Shape类是一个抽象类，通过纯虚函数draw强制派生类实现具体的绘制逻辑。多态性允许我们在renderShape函数中传递不同的形状对象，使得函数能适应多种形状的实现。

如果想深入理解设计模式和C++中的多态性，可以参考 Refactoring Guru 提供的设计模式相关内容，了解它们在实际开发中的应用场景和优势。

6天前回复举报

添加新评论

免费图表工具，画流程图、架构图

C++纯虚函数和抽象类

举报评论

删除

删除后，将不可回复，确认要删除？

提示

复制代码，请先登录