虚函数和纯虚函数的作用与区别

虚函数原理虚函数是 C++ 中一个非常重要的特性，它为面向对象编程提供了很强的支持。

虚函数的实现原理是通过虚函数表实现的，本文将介绍虚函数的概念、使用方法以及实现原理。

一、虚函数概念虚函数是指在基类中使用 virtual 关键字声明的成员函数，它的作用是允许在子类中对该函数进行覆盖。

具体来说，虚函数允许在子类中定义一个与基类中同名的函数，当使用子类对象调用该函数时，程序会动态的选择调用子类中的函数。

虚函数的语法如下：```class Base {public:virtual void foo();};```虚函数可以被重写（覆盖），也可以被继承，但是不能被 static 和 friend 修饰。

二、虚函数的使用使用虚函数需要满足一下条件：1.虚函数必须在公有的类成员函数列表中声明，并在类声明的内部定义。

2.虚函数必须在基类和派生类中以相同的参数列表进行定义。

下面是一个使用虚函数的简单例子：class Square: public Shape {public:Square(double s) : side(s) {}double getArea() { return side * side; }Shape 是一个基类，Square 是它的一个派生类，Square 中重写了 getArea() 函数，计算正方形的面积。

虚函数的实现原理是通过虚函数表实现的。

虚函数表是一个指针数组，存储了每个类中的虚函数指针。

当对象被创建时，会在其内存空间中创建一个指向虚函数表的指针，这个指针通常称为虚函数表指针（vptr），虚函数的调用就是通过这个指针完成的。

每个含有虚函数的类都有一个独立的虚函数表，虚函数表智能在类的第一个对象中存储，它包含了该类中所有虚函数的地址。

在派生类中，虚函数表通常继承自它的直接基类，并在此基础上添加或修改虚函数的地址。

这样如果在派生类对象中调用虚函数时，程序会先获得对象的虚函数表指针，然后通过该指针找到对应的虚函数地址来执行函数。

1. 析构函数和虚析构函数如果基类的析构函数是虚的，那么它的派生类的析构函数都是虚的这将导致：当派生类析构的时候，它的所有的基类的析构函数都将得到调用否则，只调用派生类的析构函数（这可能导致基类的某些对象没有得到释放）所以CObject类的析构函数是虚的，所有由它派生的类析构的时候一级一级的进行，不会造成内存泄漏。

无论基类的析构函数是否为虚析构函数. 基类的析构函数总是会被自动调用的;但是, 如果用基类指针去操作一个了派生类对象,如果不为虚就不能保证派生类的析构函数被调用。

2. 纯虚析构函数析构函数的纯虚性唯一效果就是保证抽象类的实例化。

《Effective C++》中第14条条款的一部分，既是对虚析构函数的彻底理解，亦是对纯虚析构函数作用的解释。

在某些类里声明纯虚析构函数很方便。

纯虚函数将产生抽象类——不能实例化的类（即不能创建此类型的对象）。

有些时候，你想使一个类成为抽象类，但刚好又没有任何纯虚函数。

怎么办？因为抽象类是准备被用做基类的，基类必须要有一个虚析构函数，纯虚函数会产生抽象类，所以方法很简单：在想要成为抽象类的类里声明一个纯虚析构函数。

这里是一个例子：class awov {public:virtual ~awov() = 0; // 声明一个纯虚析构函数};这个类有一个纯虚函数，所以它是抽象的，而且它有一个虚析构函数，所以不会产生析构函数问题。

但这里还有一件事：必须提供纯虚析构函数的定义：awov::~awov() {} // 纯虚析构函数的定义这个定义是必需的，因为虚析构函数工作的方式是：最底层的派生类的析构函数最先被调用，然后各个基类的析构函数被调用。

这就是说，即使是抽象类，编译器也要产生对~awov的调用，所以要保证为它提供函数体。

如果不这么做，链接器就会检测出来，最后还是得回去把它添上。

3. 虚函数【1】在基类用virtual声明成员函数为虚函数。

这样就可以在派生类中重新定义此函数，为它赋予新的功能，并能方便地被调用。

虚函数以及纯虚函数 多态性是将接⼝与实现进⾏分离；⽤形象的语⾔来解释就是实现以共同的⽅法，但因个体差异，⽽采⽤不同的策略。

虚函数和纯虚函数都是实现多态的重要⽅法。

本⽂就这两种⽅法进⾏分析以及⽐较1、虚函数在基类中声明为virtual并在⼀个或者多个派⽣类被重新定义的成员函数语法规则：virtual 函数返回类型函数名(参数表) {函数体}语法分析：虚函数的声明和定义和普通的成员函数⼀样，只是在返回值之前加⼊了关键字virtual。

在基类当中定义了虚函数，可以再⼦类中定义和基类中相同函数名、相同参数、相同返回值和不同实现体的虚函数 定义为虚函数是为了让基类函数的指针或者引⽤来指向⼦类。

#include<iostream>using namespace std;class A{public:void fun(){cout << "A::fun()..." << endl;}};class B :public A{public:void fun(){cout << "B::fun()...." << endl;}};int main(){A *a = new A; //A类指针指向A类对象a->fun();A *b = new B; //A类指针指向B类对象b->fun();delete a;delete b;return0;}分析代码：在上述代码中B为A的派⽣类，A *b=new B 是将基类的指针指向B 类对象。

输出为：显然程序没有实现我们想要的输出#include<iostream>using namespace std;class A{public:virtual void fun(){cout << "A::fun()..." << endl;}};class B :public A{public:void fun(){cout << "B::fun()...." << endl;}};int main(){A *a = new A; //A类指针指向A类对象a->fun();A *b = new B; //A类指针指向B类对象b->fun();delete a;delete b;return0;}分析：可以看出利⽤虚函数可以实现多态，也就是说实现了通过不同对象的接⼝实现了不同的功能。

C++虚函数及虚函数表解析虚函数的定义： 虚函数必须是类的⾮静态成员函数（且⾮构造函数），其访问权限是public（可以定义为private or proteceted，但是对于多态来说，没有意义。

），在基类的类定义中定义虚函数的⼀般形式： virtual 函数返回值类型虚函数名（形参表） { 函数体 } 虚函数的作⽤是实现动态联编，也就是在程序的运⾏阶段动态地选择合适的成员函数，在定义了虚函数后， 可以在基类的派⽣类中对虚函数重新定义（形式也是：virtual 函数返回值类型虚函数名（形参表）{ 函数体 }），在派⽣类中重新定义的函数应与虚函数具有相同的形参个数和形参类型。

以实现统⼀的接⼝，不同定义过程。

如果在派⽣类中没有对虚函数重新定义，则它继承其基类的虚函数。

当程序发现虚函数名前的关键字virtual后，会⾃动将其作为动态联编处理，即在程序运⾏时动态地选择合适的成员函数。

实现动态联编需要三个条件： 1、必须把需要动态联编的⾏为定义为类的公共属性的虚函数。

2、类之间存在⼦类型关系，⼀般表现为⼀个类从另⼀个类公有派⽣⽽来。

3、必须先使⽤基类指针指向⼦类型的对象，然后直接或者间接使⽤基类指针调⽤虚函数。

定义虚函数的限制： （1）⾮类的成员函数不能定义为虚函数，类的成员函数中静态成员函数和构造函数也不能定义为虚函数，但可以将析构函数定义为虚函数。

实际上，优秀的程序员常常把基类的析构函数定义为虚函数。

因为，将基类的析构函数定义为虚函数后，当利⽤delete删除⼀个指向派⽣类定义的对象指针时，系统会调⽤相应的类的析构函数。

⽽不将析构函数定义为虚函数时，只调⽤基类的析构函数。

（2）只需要在声明函数的类体中使⽤关键字“virtual”将函数声明为虚函数，⽽定义函数时不需要使⽤关键字“virtual”。

（3）如果声明了某个成员函数为虚函数，则在该类中不能出现和这个成员函数同名并且返回值、参数个数、参数类型都相同的⾮虚函数。

虚函数与纯虚函数的区别1. 虚函数和纯虚函数可以定义在同⼀个类(class)中，含有纯虚函数的类被称为抽象类(abstract class)，⽽只含有虚函数的类(class)不能被称为抽象类(abstract class)。

2. 虚函数可以被直接使⽤，也可以被⼦类(sub class)重载以后以多态的形式调⽤，⽽纯虚函数必须在⼦类(sub class)中实现该函数才可以使⽤，因为纯虚函数在基类(base class)只有声明⽽没有定义。

3. 虚函数和纯虚函数都可以在⼦类(sub class)中被重载，以多态的形式被调⽤。

4. 虚函数和纯虚函数通常存在于抽象基类(abstract base class -ABC)之中，被继承的⼦类重载，⽬的是提供⼀个统⼀的接⼝。

5. 虚函数的定义形式：virtual {method body} 纯虚函数的定义形式：virtual { } = 0;在虚函数和纯虚函数的定义中不能有static标识符，原因很简单，被static修饰的函数在编译时候要求前期bind,然⽽虚函数却是动态绑定(run-time bind)，⽽且被两者修饰的函数⽣命周期(life recycle)也不⼀样。

6. 虚函数必须实现，如果不实现，编译器将报错，错误提⽰为：error LNK****: unresolved external symbol "public: virtual void __thiscallClassName::virtualFunctionName(void)"7. 对于虚函数来说，⽗类和⼦类都有各⾃的版本。

由多态⽅式调⽤的时候动态绑定。

8. 实现了纯虚函数的⼦类，该纯虚函数在⼦类中就编程了虚函数，⼦类的⼦类即孙⼦类可以覆盖该虚函数，由多态⽅式调⽤的时候动态绑定。

9. 虚函数是C++中⽤于实现多态(polymorphism)的机制。

核⼼理念就是通过基类访问派⽣类定义的函数10. 多态性指相同对象收到不同消息或不同对象收到相同消息时产⽣不同的实现动作。

虚函数是C++中的一个非常重要的概念，它允许我们在派生类中重新定义基类中的函数，从而实现多态性。

在本文中，我们将深入探讨virtual关键字的作用，以及virtual函数和纯虚函数的使用方法。

在C++中，virtual关键字用于声明一个虚函数。

这意味着当派生类对象调用该函数时，将会调用其在派生类中的定义，而不是基类中的定义。

这种行为使得我们能够在派生类中定制化地实现函数的逻辑，从而实现不同对象的不同行为。

对于virtual函数，我们需要注意以下几点：1. 在基类中声明函数时，使用virtual关键字进行声明。

2. 派生类中可以选择性地使用virtual关键字进行重声明，但通常最好也使用virtual，以便明确表明这是一个虚函数。

3. 当使用派生类对象调用虚函数时，将会根据对象的实际类型调用适当的函数实现。

4. 虚函数的实现通过虚函数表（vtable）来实现，这是一张函数指针表，用于存储各个虚函数的位置区域。

除了普通的虚函数外，C++还提供了纯虚函数的概念。

纯虚函数是在基类中声明的虚函数，它没有函数体，只有声明。

这意味着基类不能直接实例化，只能用作其他类的基类。

纯虚函数通常用于定义一个接口，而具体的实现则留给派生类。

接下来，让我们以一个简单的例子来说明虚函数和纯虚函数的用法。

假设我们有一个基类Shape，它包含一个纯虚函数calcArea用于计算面积。

有两个派生类Circle和Rectangle，它们分别实现了calcArea 函数来计算圆形和矩形的面积。

在这个例子中，我们可以看到基类Shape定义了一个纯虚函数calcArea，它没有函数体。

而派生类Circle和Rectangle分别实现了这个函数来计算不同形状的面积。

当我们使用Shape指针指向Circle或Rectangle对象时，调用calcArea函数将会根据对象的实际类型来调用适当的实现。

除了虚函数和纯虚函数外，C++中还有虚析构函数的概念。

纯虚函数空函数一、纯虚函数纯虚函数是指在基类中声明但没有定义的虚函数，它的作用是为派生类提供一个接口，派生类必须实现这个函数。

纯虚函数的声明语法为：virtual 返回类型函数名(参数列表) =0;其中“=0”表示该函数为纯虚函数。

纯虚函数的特点：1.没有函数体。

在基类中声明但没有提供函数的具体实现，从而使得基类成为了抽象类，不能被实例化。

2.继承。

子类必须实现纯虚函数，否则也将成为抽象类，无法被实例化。

3.多态性。

子类中实现了基类的纯虚函数后，可以通过基类指针调用子类的实现。

1.抽象类。

基类中有至少一个纯虚函数时，该基类就成为了抽象类。

抽象类不能被实例化，只能被其他类继承和实现。

2.接口。

纯虚函数提供了一种接口，规定了子类必须实现的方法。

这种方法被称为“接口”。

让我们创建一个基类Figure，定义一个纯虚函数area()，用于计算图形的面积。

代码如下：class Figure{public:virtual double area() = 0;};class Circle : public Figure{public:Circle(double r){radius = r;}double area(){return 3.1415926 * radius * radius; // 计算圆的面积}private:double radius;};使用上述代码创建一个程序，可以通过基类指针调用子类实现的结果。

代码如下：以上程序会输出圆的面积，结果如下：Circle's area is:314.15926二、空函数空函数是指没有任何实际功能的函数，用于占位或在后续开发中替换为有用的函数。

空函数的定义语法为：void 函数名(){}1.通常没有函数体，函数体中只有一个空语句，表示不需要执行任何操作。

2.占位。

空函数可以用作占位函数来占据函数列表中的某些位置，等待日后补充功能。

3.代码兼容性。

空函数可以提高代码的兼容性，当代码需要调用某个函数时，即使函数还未完成，也可以使用空函数来代替。

纯函数与虚函数简介在计算机编程中，纯函数（Pure Function）和虚函数（Virtual Function）是两个重要的概念。

纯函数是指在相同的输入下，总是返回相同的输出，并且没有任何副作用。

而虚函数是用于实现多态的机制，可以在子类中重写父类的方法。

本文将对纯函数和虚函数进行全面、详细、完整且深入地探讨。

纯函数定义纯函数是指对于相同的输入，总是得到相同的输出，并且没有任何副作用的函数。

纯函数不依赖于外部状态，只依赖于输入参数。

它的输出只取决于输入，与外部环境无关。

特点•相同的输入总是得到相同的输出。

•不会产生任何副作用，不修改外部状态。

示例以下是一个纯函数的示例：int square(int n) {return n * n;}这个函数接受一个整数作为输入，并返回它的平方。

无论何时调用这个函数，只要输入相同，输出就会相同。

这个函数没有任何副作用，不会修改任何外部状态。

优点纯函数具有以下优点： 1. 易于测试和调试：由于纯函数不依赖于外部状态，其行为仅取决于输入，因此很容易编写测试用例并进行测试和调试。

2. 容易并行化：由于纯函数没有任何副作用，可以放心地将其应用于多个并发任务，而无需担心竞态条件和不确定的结果。

3. 更易于理解和维护：纯函数的行为仅取决于输入参数，因此更容易理解和维护。

虚函数定义虚函数是用于实现多态的机制。

在面向对象编程中，虚函数是指在基类中声明的方法，可以被子类重新定义。

通过使用虚函数，可以在运行时根据对象的实际类型调用相应的方法。

特点•在基类中声明，在子类中重写。

•可以根据对象的实际类型调用相应的方法，实现多态。

示例以下是一个使用虚函数实现多态的示例：class Animal {public:virtual void speak() {cout << "Animal speaks" << endl;}};class Dog : public Animal {public:void speak() {cout << "Dog barks" << endl;}};class Cat : public Animal {public:void speak() {cout << "Cat meows" << endl;}};int main() {Animal* animal1 = new Animal();Animal* animal2 = new Dog();Animal* animal3 = new Cat();animal1->speak(); // 输出：Animal speaksanimal2->speak(); // 输出：Dog barksanimal3->speak(); // 输出：Cat meowsreturn 0;}在上面的示例中，Animal 是一个基类，它有一个名为 speak 的虚函数。

C++之普通成员函数、虚函数以及纯虚函数的区别与⽤法要点普通成员函数是静态编译的，没有运⾏时多态，只会根据指针或引⽤的“字⾯值”类对象，调⽤⾃⼰的普通函数；虚函数为了重载和多态的需要，在基类中定义的，即便定义为空；纯虚函数是在基类中声明的虚函数，它可以再基类中有定义，且派⽣类必须定义⾃⼰的实现⽅法。

假设我们有三个类Person、Teacher、Student它们之间的关系如下：类的关系图普通成员函数【Demo1】根据这个类图，我们有下⾯的代码实现#ifndef __OBJEDT_H__#define __OBJEDT_H__#include <string>#include <iostream>class Person{public:Person(const string& name, int age) : m_name(name), m_age(age){}void ShowInfo(){cout << "姓名：" << m_name << endl;cout << "年龄：" << m_age << endl;}protected:string m_name; //姓名int m_age; //年龄};class Teacher : public Person{public:Teacher(const string& name, int age, const string& title): Person(name, age), m_title(title){}void ShowInfo(){cout << "姓名：" << m_name << endl;cout << "年龄：" << m_age << endl;cout << "职称：" << m_title << endl;}private:string m_title; //职称};class Student : public Person{public:Student(const string& name, int age, int studyId): Person(name, age), m_studyId(studyId){}void ShowInfo(){cout << "姓名：" << m_name << endl;cout << "年龄：" << m_age << endl;cout << "学号：" << m_studyId << endl;}private:int m_studyId; //学号};#endif //__OBJEDT_H__测试代码：void test(){Person* pPerson = new Person("张三", 22);Teacher* pTeacher = new Teacher("李四", 35, "副教授");Student* pStudent = new Student("王五", 18, 20151653);pPerson->ShowInfo();cout << endl;pTeacher->ShowInfo();cout << endl;pStudent->ShowInfo();cout << endl;delete pPerson;delete pTeacher;delete pStudent;}结果：姓名：张三年龄：22姓名：李四年龄：35职称：副教授姓名：王五年龄：18学号：20151653说明：这⾥的ShowInfo就是⼀个普通的函数。

纯函数与虚函数
纯函数与虚函数是面向对象编程中的两个重要概念。

纯函数是指没有副作用的函数，也就是说函数的返回值仅仅依赖于其输入参数，不会对外部状态进行修改。

虚函数则是指在基类中被声明为虚函数，并在派生类中进行重写的函数。

虚函数的实现是通过虚函数表来实现的，虚函数表记录了各个类中虚函数的指针。

通过虚函数，可以实现多态特性，即在运行时根据对象的实际类型来调用相应的函数。

纯函数和虚函数在编程中的应用场景有所不同。

纯函数主要用于函数式编程，它们比较适合处理数学上的问题，例如计算函数的值。

纯函数一般没有副作用，可以对代码的可读性和维护性产生积极的作用。

虚函数则主要用于面向对象编程，它们可以实现多态特性，在代码的扩展性和复用性方面有很大的帮助。

通过虚函数，可以将基类的指针或引用指向派生类的对象，从而实现对派生类中重写的函数的调用。

总之，纯函数和虚函数都是面向对象编程中重要的概念，它们各自具有不同的应用场景和特点，对于程序员来说，了解和掌握它们的使用方法，可以提高代码的质量和效率。

- 1 -。