当前位置：首页 > wzjs >正文

哪个做h5的网站好用朋友圈广告推广

wzjs 2025/7/21 3:26:49

哪个做h5的网站好用,朋友圈广告推广,住房和城乡建设委员会网站,微信公众号开发是否需要建立网站C多态与虚函数详解——从入门到精通引言在C面向对象编程中，多态是一个核心概念，它赋予了程序极大的灵活性和扩展性。本文将通过六个精心设计的实例，深入浅出地讲解C中的多态、虚函数、继承和抽象类等概念，帮助初学者快速理解这…

C++多态与虚函数详解——从入门到精通

引言

在C++面向对象编程中，多态是一个核心概念，它赋予了程序极大的灵活性和扩展性。本文将通过六个精心设计的实例，深入浅出地讲解C++中的多态、虚函数、继承和抽象类等概念，帮助初学者快速理解这些重要的面向对象特性。

一、基本多态实现

#include <iostream>
using namespace std;class Base {
public:// 虚函数声明，使得派生类可以重写该函数virtual void show() { cout << "Base" << endl; }  // 基类的show方法
};class Derived : public Base {
public:// override关键字明确表示这是对基类虚函数的重写void show() override { cout << "Derived" << endl; }  // 派生类重写show方法
};int main() {// 关键点：基类指针指向派生类对象Base* b = new Derived();  // 基类指针指向派生类对象b->show();  // 调用的是派生类的show方法，输出"Derived"delete b;   // 释放内存return 0;
}

代码解析：

这个例子展示了C++多态的基础实现。通过在基类中声明virtual函数，并在派生类中重写该函数。
当使用基类指针指向派生类对象并调用虚函数时，会根据指针实际指向的对象类型调用相应的函数实现。
这里输出结果为Derived，展示了动态绑定的特性。

二、虚函数与普通函数的区别

#include <iostream>
using namespace std;class A {
public:// 虚函数会根据对象的实际类型动态绑定virtual void func() { cout << "A::func" << endl; }  // 虚函数// 普通函数根据指针或引用的静态类型绑定void test() { cout << "A::test" << endl; }  // 非虚函数
};class B : public A {
public:// 重写基类的虚函数void func() override { cout << "B::func" << endl; }  // 重写虚函数// 这不是重写，而是隐藏基类的同名函数void test() { cout << "B::test" << endl; }  // 隐藏基类的同名函数
};int main() {A* obj = new B();  // 基类指针指向派生类对象obj->func();  // 调用B::func，体现多态obj->test();  // 调用A::test，静态绑定delete obj;return 0;
}

代码解析：

这个例子清晰地展示了虚函数与普通函数在多态场景中的区别。
func()是虚函数，会根据对象的实际类型动态绑定，因此输出B::func。
test()是普通函数，根据指针的静态类型绑定，因此输出A::test。
这个区别是C++多态机制的核心，明确理解这一点对掌握多态至关重要。

三、多层继承中的虚函数

#include <iostream>
using namespace std;class Grandparent {
public:// 在最顶层基类声明虚函数virtual void foo() { cout << "Grandparent::foo" << endl; }  // 祖父类的虚函数
};class Parent : public Grandparent {
public:// 中间层重写虚函数void foo() override { cout << "Parent::foo" << endl; }  // 父类重写虚函数
};class Child : public Parent {
public:// 最下层再次重写虚函数void foo() override { cout << "Child::foo" << endl; }  // 子类重写虚函数
};int main() {// 祖父类指针指向孙子类对象Grandparent* gp = new Child();  // 基类指针指向最终派生类gp->foo();  // 调用的是Child::foo，体现多态特性delete gp;return 0;
}

代码解析：

这个例子展示了多层继承中的虚函数工作机制。
虚函数一旦在基类中声明为virtual，在整个继承链中都保持虚函数的特性。
即使使用最顶层的基类指针，只要指向的是子类对象，调用虚函数时会一直追踪到最终的实现。
输出结果为Child::foo，展示了多层继承中的动态绑定特性。

四、虚析构函数的重要性

#include <iostream>
using namespace std;class Base {
public:// 虚析构函数确保正确析构派生类对象virtual ~Base() { cout << "Base destructor" << endl; }  // 虚析构函数
};class Derived : public Base {
public:// 派生类的析构函数~Derived() { cout << "Derived destructor" << endl; }  // 派生类析构函数
};int main() {Base* b = new Derived();  // 基类指针指向派生类对象delete b;  // 会先调用Derived的析构函数，再调用Base的析构函数return 0;
}

代码解析：

这个例子展示了虚析构函数的重要性。
当使用基类指针删除派生类对象时，如果析构函数不是虚函数，则只会调用基类的析构函数，可能导致派生类资源泄漏。
有了虚析构函数，delete操作会先调用派生类的析构函数，再调用基类的析构函数，确保资源被正确释放。
输出顺序为：Derived destructor然后是Base destructor，体现了对象销毁的正确顺序。

五、多重继承中的析构顺序

#include <iostream>
using namespace std;class A {
public:// A的虚析构函数virtual ~A() {cout << "A destructor" << endl;  // A类析构函数}
};class B {
public:// B的虚析构函数virtual ~B() {cout << "B destructor" << endl;  // B类析构函数}
};class C : public A, public B {
public:// C的析构函数~C() {cout << "C destructor" << endl;  // C类析构函数}
};int main() {A* a = new C();  // A类型指针指向C类对象delete a;  // 析构函数调用次序：C->A->Breturn 0;
}

代码解析：

这个例子展示了多重继承中虚析构函数的工作方式和析构顺序。
C类同时继承了A和B，当通过A类型的指针删除C类对象时：
1. 首先调用派生类C的析构函数
2. 然后调用直接基类A的析构函数
3. 最后，由于没有通过B类型的指针，所以B的析构函数不会被调用，这可能导致资源泄露
实际输出是：C destructor然后是A destructor，缺少了B的析构函数调用。
注意： 这里有一个潜在的资源泄露问题，因为B的析构函数没有被调用。在实际开发中，应当避免这种情况，或确保所有基类的资源都能被正确释放。

六、纯虚函数与抽象类

#include<iostream>
using namespace std;class Shape {
public:// 纯虚函数，使Shape成为抽象类virtual double area() = 0;  // 纯虚函数，无实现
};class Circle : public Shape {
private:double radius;  // 圆的半径
public:// 构造函数初始化半径Circle(double r) : radius(r) {}// 实现基类的纯虚函数double area() override {return 3.14 * radius * radius;  // 计算圆的面积：πr²}
};int main() {// 不能直接实例化抽象类，但可以创建其派生类的对象Shape* s = new Circle(5);  // 基类指针指向派生类对象cout << "Area: " << s->area() << endl;  // 输出圆的面积delete s;return 0;
}