C++多态与虚函数

提示信息

阿全

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

C++中的多态性是一种面向对象的特性，允许不同的对象对同一函数作出不同的响应。多态性通过虚函数来实现。

虚函数是在基类中声明的函数，它被继承的子类所重写。通过将基类的函数声明为虚函数，可以在运行时确定要调用的实际函数（根据对象的类型）。这样，即使使用基类指针或引用来调用函数，实际上也会根据对象的类型调用相应的派生类函数。

为使函数成为虚函数，在声明函数时需要在函数名前面加上virtual关键字。派生类中重写虚函数时，使用override关键字标识该函数为重写的虚函数。

例如，假设有一个基类Animal和两个派生类Dog和Cat，它们都有虚函数sound():

class Animal {  
public:  
    virtual void sound() {  
        std::cout << "Animal makes a sound" << std::endl;  
    }  
};  
class Dog : public Animal {  
public:  
    void sound() override {  
        std::cout << "Dog barks" << std::endl;  
    }  
};  
class Cat : public Animal {  
public:  
    void sound() override {  
        std::cout << "Cat meows" << std::endl;  
    }  
};

然后可以通过基类指针调用虚函数，根据实际对象的类型调用相应的函数：

int main() {  
    Animal* animal1 = new Dog();  
    Animal* animal2 = new Cat();  
    animal1->sound(); // Output: "Dog barks"  
    animal2->sound(); // Output: "Cat meows"  
    delete animal1;  
    delete animal2;  
    return 0;  
}

这样，无论基类指针指向的是Dog对象还是Cat对象，调用sound()函数时都会根据对象的类型相应地输出不同的结果。这就是C++中的多态性与虚函数的实现。

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

阿全赞 | 0

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

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

20条评论

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

墨色

10月11日

很详细的解释，多态性真的让代码更灵活。

赞 0 回复举报

伊轩： @墨色

很高兴看到多态性给代码带来了灵活性。多态确实是C++中一个非常强大的特性，能够让我们以更抽象的方式处理对象。

例如，通过定义一个基类和多个派生类，可以利用虚函数实现不同方法的行为。以下是一个简单的示例：

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() const {
        cout << "Drawing a generic shape." << endl;
    }
};

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

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

void render(const Shape& shape) {
    shape.draw();
}

int main() {
    Circle circle;
    Square square;

    render(circle);  // Outputs: Drawing a circle.
    render(square);  // Outputs: Drawing a square.

    return 0;
}

在这个例子中，render函数接受一个Shape类型的引用，可以适用于所有派生的形状类。这种方式使得我们可以在不修改render函数的情况下，轻松地添加新的形状类型。对于更深入的多态实践，可能会发现一些高级用法，如使用抽象基类和接口设计，这样有助于确保派生类实现某些行为。

如果对多态和虚函数的实现有更多兴趣，可以参考 C++参考文献了解更多详尽信息。

11月13日回复举报

添加新评论

不安情

10月18日

文章清晰，但可以补充一下override的作用。

赞 0 回复举报

浮云： @不安情

对于多态和虚函数的讨论，确实在现代C++中，使用override关键字来指明一个虚函数的重写是一个很好的实践。它不仅提高了代码的可读性，还能在编译阶段帮助捕捉潜在的错误。例如，如果基类的函数签名发生了变化而子类中没有相应修改，编译器会发出警告，帮助开发者及时调整。这能有效避免由于拼写错误或参数不匹配带来的逻辑错误。

以下是一个简单示例：

class Base {
public:
    virtual void show() {
        std::cout << "Base show" << std::endl;
    }
};

class Derived : public Base {
public:
    void show() override { // 使用override标记
        std::cout << "Derived show" << std::endl;
    }
};

如果在Derived类中将show函数的签名写错，例如将参数类型更改而不使用override，编译器可能不会提示错误，而运行时可能会导致不可预测的结果。使用override则能及时发现这种问题。

更多关于C++中的override和虚函数的细节可以参考C++标准文档或现代C++书籍，例如 C++ Primer.

11月12日回复举报

添加新评论

旧七月

10月21日

多态性确实是C++核心概念，能简化函数调度过程。文中的例子讲述的很好，直接体现了如何利用虚函数实现多态。

赞 0 回复举报

事与愿违い： @旧七月

对于多态性的理解，可以通过简化的代码示例来更深入地掌握虚函数的应用。以下是一个简单的例子，展示了如何利用虚函数实现多态：

#include <iostream>
using namespace std;

class Animal {
public:
    virtual void sound() {
        cout << "Some generic animal sound" << endl;
    }
};

class Dog : public Animal {
public:
    void sound() override {
        cout << "Woof!" << endl;
    }
};

class Cat : public Animal {
public:
    void sound() override {
        cout << "Meow!" << endl;
    }
};

void makeSound(Animal* animal) {
    animal->sound();
}

int main() {
    Dog dog;
    Cat cat;

    makeSound(&dog);  // 输出: Woof!
    makeSound(&cat);  // 输出: Meow!

    return 0;
}

在这个示例中，Animal 类作为基类，定义了一个虚函数 sound()，而 Dog 和 Cat 类分别重写了这个函数。通过指向基类的指针 animal，可以动态地调用子类实现的 sound() 函数。这种灵活性展示了多态的强大之处，简化了代码的扩展和维护。

在学习这一概念时，考虑一些更复杂的场景，如使用纯虚函数实现接口，从而提高代码的可扩展性和可维护性。如果有兴趣，可以参考更多示例和细节，推荐阅读 LearnCpp 的多态章节。理解多态的深层含义，对掌握C++编程会大有裨益。

3天前回复举报

添加新评论

一座

10月31日

对于初学者，理解虚函数的动态绑定有些复杂，文章对此讲的还可以，建议多看https://en.cppreference.com/w/cpp/language/virtual

赞 0 回复举报

物是： @一座

理解虚函数与动态绑定的确需要一些时间和实践。可以通过简单的示例来加深这方面的理解。

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() { // 虚函数
        cout << "Base class show function called." << endl;
    }
};

class Derived : public Base {
public:
    void show() override { // 重写虚函数
        cout << "Derived class show function called." << endl;
    }
};

void display(Base* obj) { // 接收基类指针
    obj->show(); // 调用虚函数
}

int main() {
    Base b;
    Derived d;
    display(&b); // 调用基类的 show()
    display(&d); // 调用派生类的 show()
    return 0;
}

在这个例子中，show函数在基类中被声明为虚函数，并在派生类中被重写。通过基类指针调用show函数时，会根据对象的实际类型确定要调用哪个版本的函数。这种动态绑定的机制使得程序能更灵活地处理多态性。

此外，了解override和final关键词的使用也可以帮助理清思路。参考链接 https://en.cppreference.com/w/cpp/language/virtual，这能提供更深入的例子和解释，特别是关于运行时多态性及其内部机制的专门讨论。

5天前回复举报

添加新评论

把爱

11月04日

虚函数有助于面向对象编程思想的深入理解，推荐学习继承和多态结合提高代码复用性。

赞 0 回复举报

沦陷的痛： @把爱

虚函数在实现多态性方面确实具有重要作用，能有效提高代码的灵活性和可扩展性。通过基类指针调用派生类的函数，可以在运行时决定具体执行哪个版本，真是应证了"面向接口编程，而不是面向实现"的理念。

以下是一个简单的示例，展示了如何利用虚函数实现多态：

#include <iostream>
using namespace std;

class Base {
public:
    virtual void show() {
        cout << "Base class" << endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        cout << "Derived class" << endl;
    }
};

void display(Base* base) {
    base->show(); // 调用的是实际对象的show()方法
}

int main() {
    Base b;
    Derived d;

    display(&b); // 输出: Base class
    display(&d); // 输出: Derived class

    return 0;
}

在这个例子中，display函数接受基类指针参数，而在运行时根据传入的对象类型调用相应的show方法。这种结构不仅提升了代码复用性，更让维护和拓展变得更加容易。

对于进一步的学习，可以参考LearnCpp，该网站提供了丰富的C++教程，包括虚函数和多态性等高级主题的深入剖析。继续探索面向对象的世界，能够让编程更加高效与优雅。

11月13日回复举报

添加新评论

韦爱珍

11月09日

代码演示直接明了，展示了多态性的特点。

赞 0 回复举报

韦成躏： @韦爱珍

对于多态的理解，可以通过具体的代码示例来更好地体会其特性。例如，考虑一个简单的图形绘制的例子，我们可以定义一个基类Shape，然后使用多态创建不同形状的子类。

#include <iostream>
using namespace std;

class Shape {
public:
    virtual void draw() const {
        cout << "Drawing a shape." << endl;
    }
};

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

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

void render(const Shape& shape) {
    shape.draw();
}

int main() {
    Circle circle;
    Square square;

    render(circle);  // 输出: Drawing a circle.
    render(square);  // 输出: Drawing a square.

    return 0;
}

在这个示例中，通过Shape类的引用参数来实现多态，使得可以在运行时调用不同子类的draw方法。这样的设计模式不仅提高了代码的灵活性和可维护性，还降低了耦合度。可以进一步参考关于设计模式的内容，如《设计模式：可复用面向对象软件的基础》。这能够为深入理解多态提供更多的实例与理论支持。

11月12日回复举报

添加新评论

l15335803

11月21日

通过虚函数实现的多态，在实际开发中广泛应用，尤其在设计大型项目时非常有帮助。

赞 0 回复举报

铃铛： @l15335803

在C++中，利用虚函数实现的多态确实是大型项目设计中一个不可或缺的特性。通过虚函数，我们可以将派生类的对象都视作基类的对象，从而使得代码的扩展性和可维护性得到极大的提升。这种设计策略在实现策略模式、工厂模式等时尤为有效。

例如，可以定义一个基类Shape，并在其派生类Circle和Rectangle中重写draw方法：

#include <iostream>
using namespace std;

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

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

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

void render(const Shape& shape) {
    shape.draw();
}

int main() {
    Circle circle;
    Rectangle rectangle;
    render(circle);        // Outputs: Drawing Circle
    render(rectangle);     // Outputs: Drawing Rectangle
    return 0;
}

通过这种方式，只需通过基类指针或引用调用draw方法，程序便会根据实际对象的类型决定调用哪个具体实现，这大大降低了代码的耦合度。

此外，对于希望深入了解多态和虚函数的工作机制，可以查阅一些优秀的 C++ 书籍或在线教程，如 C++ Primer 或 LearnCPP，那里有更详细的说明和配套示例，能够帮助更好地掌握这一重要特性。

5天前回复举报

添加新评论

浮尘

11月30日

例子中的override关键字提升了代码的可读性和安全性，防止未预期的行为出现。

赞 0 回复举报

未央： @浮尘

对于使用 override 关键字的做法，确实值得注意。它不仅增加了代码的可读性，还能有效降低 bugs 的出现。比如，在一个基类中定义了一个虚函数，但子类不小心拼写错误或者更改了参数，就可能导致未预期的行为，而通过 override，编译器会对这些情况进行检查，帮助开发者明确函数的意图。

例如，考虑以下代码：

class Base {
public:
    virtual void foo() {}
};

class Derived : public Base {
public:
    void foo() override {} // 合法
    void bar() override {} // 错误，bar不是Base的虚函数
};

在此例中，foo 使用了 override 关键字，强调它重写了基类的虚函数。而 bar 如果尝试使用 override，编译器将会报错，提示它与基类不匹配，防止潜在的逻辑错误。

同时，建议深入了解 C++ 标准库中关于多态和虚函数的内容，像是 C++ Reference 上有丰富的相关资料，能够帮助更好地理解多态性的实现及其最佳实践。这样不仅能提高代码质量，还能更方便地进行团队协作。

11月10日回复举报

添加新评论

心语愿

12月12日

例子状态清楚，可以增加多态性与纯虚函数的结合用途，以丰富文章内容。

赞 0 回复举报

饮风游侠： @心语愿

对于将在C++中使用多态性和纯虚函数结合的建议，确实是一个富有深度的方向。多态性和纯虚函数的结合能够帮助更好地实现接口设计以及抽象类的特性。这样的设计不仅能够提高代码的可扩展性，还能确保派生类必须实现特定的功能。

例如，可以创建一个抽象类Shape，它包含一个纯虚函数draw()，然后每个具体的形状类（如Circle和Square）都必须实现这个方法。这样一来，不同的图形可以通过相同的接口进行处理。

#include <iostream>
#include <vector>

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 renderShapes(const std::vector<Shape*>& shapes) {
    for (const auto& shape : shapes) {
        shape->draw(); // 多态性
    }
}

int main() {
    Circle circle;
    Square square;
    std::vector<Shape*> shapes = {&circle, &square};
    renderShapes(shapes);
    return 0;
}

通过这种方式，可以在运行时根据实际对象的类型来调用相应的draw()方法，展示多态性的强大之处。想了解更多关于多态和虚函数结合的应用，可以参考GeeksforGeeks中的相关内容。这能够帮助更深入理解这一特性的实际应用。

11月09日回复举报

添加新评论

似有似无い

12月22日

对于面向对象编程，理解多态至关重要，能够使得程序更加灵活，可以根据运行时情况选择不同的方法执行。这个例子在教育层面显得相当经典！推荐在学习时尝试自己写类似的例子，加深理解。

赞 0 回复举报

韦庭星： @似有似无い

对于多态的理解，确实是面向对象编程中的一个关键点。在实际编码中，使用虚函数能够让我们在运行时选择不同的实现，这为程序的灵活性和可扩展性提供了很大的便利。

例如，考虑一个简单的形状基类和两个派生类，圆形和矩形。通过使用虚函数，我们可以在运行时决定调用哪个形状的面积计算方法。示例如下：

#include <iostream>

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.14 * 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;
    }
};

void printArea(const Shape& shape) {
    std::cout << "Area: " << shape.area() << std::endl;
}

int main() {
    Circle circle(5);
    Rectangle rectangle(4, 6);

    printArea(circle);
    printArea(rectangle);

    return 0;
}

这里的Shape类是一个抽象基类，定义了一个纯虚函数area()。Circle和Rectangle类继承自Shape，并各自实现area()方法。在printArea函数中，我们可以传入任何实现了Shape接口的对象，其所调用的方法基于实际传入的对象。

对于学习者来说，尝试写自己的多态示例并观察运行效果，能有效加深理解。此外，还可以参考LearnCpp.com来获取更多关于C++多态的知识和示例。

11月09日回复举报

添加新评论

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

C++多态与虚函数

举报评论

删除

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

提示

复制代码，请先登录