纯虚函数 空函数
纯函数虚函数
纯函数虚函数
纯函数和虚函数是C++语言中重要的概念。
纯函数指的是在函数
体内不使用任何外部变量，且函数的返回值只依赖于输入参数的值，
即不会受到任何其他因素的影响，相同的输入永远会得到相同的输出。
因此，纯函数不会产生任何副作用，也就是说，不会改变外部环境的
状态。
纯函数在并发编程和函数式编程中应用广泛。
虚函数是一种在基类中声明的成员函数，它可以被派生类重新定义。
虚函数通过使用动态绑定，实现在运行时确定调用哪个类的函数。
作为虚函数的重要应用，多态性使得代码更加灵活，可以更好地适应
变化。
在C++中，对于类中的成员函数，可以将其声明为纯函数和虚函数，也可以同时声明为纯虚函数和虚函数。
纯虚函数是指在基类中声
明的函数，但没有给出函数实现，需要在派生类中定义函数实现。
虚
函数和纯虚函数都可以使用override关键字来在派生类中重定义，从
而实现更加灵活的代码结构。
C++基抽象类的构造析构（纯）虚函数
C++基抽象类的构造析构（纯）虚函数⼀、析构函数可定义为⼀、析构函数可定义为纯虚函数纯虚函数，但也必须给出函数定义，但也必须给出函数定义 Effective C++ 条歀07: 为多态基类声明virtual 析构函数（Declare destructors virtual in polymorphic base classes ） 在某些类⾥声明纯虚析构函数很⽅便。
纯虚函数将产⽣抽象类——不能实例化的类（即不能创建此类型的对象）。
有些时候，你想使⼀个类成为抽象类，但刚好⼜没有任何纯虚函数。
怎么办？因为抽象类是准备被⽤做基类的，基类必须要有⼀个虚析构函数，纯虚函数会产⽣抽象类，所以⽅法很简单：在想要成为抽象类的类⾥声明⼀个纯虚析构函数。
1 //这⾥是⼀个例⼦：2 class awov {3 public :4 virtual ~awov() = 0; // 声明⼀个纯虚析构函数5 }; 这个类有⼀个纯虚函数，所以它是抽象的，⽽且它有⼀个虚析构函数，所以不会产⽣析构函数问题。
但这⾥还有⼀件事：必须提供纯虚析构函数的定义： awov::~awov() { ... } // 纯虚析构函数的定义 这个定义是必需的，因为虚析构函数⼯作的⽅式是：最底层的派⽣类的析构函数最先被调⽤，然后各个基类的析构函数被调⽤。
这就是说，即使是抽象类，编译器也要产⽣对~awov 的调⽤，所以要保证为它提供函数体。
如果不这么做，链接器就会检测出来，最后还是得回去把它添上。
⼆、？ 关于C++为什么不⽀持虚拟构造函数，Bjarne 很早以前就在C++Style and Technique FAQ ⾥⾯做过回答 Avirtual call is a mechanism to get work done given partialinformation. In particular, "virtual" allows us to call afunction knowing only an interfaces and not the exact type of theobject. To create an object you need complete information.Inparticular, you need to know the exact type of what you want tocreate. Consequently, a "call to a constructor" cannot bevirtual. 含义⼤概是这样的：虚函数调⽤是在部分信息下完成⼯作的机制，允许我们只知道接⼝⽽不知道对象的确切类型。
虚函数以及纯虚函数
虚函数以及纯虚函数 多态性是将接⼝与实现进⾏分离；⽤形象的语⾔来解释就是实现以共同的⽅法，但因个体差异，⽽采⽤不同的策略。
虚函数和纯虚函数都是实现多态的重要⽅法。
本⽂就这两种⽅法进⾏分析以及⽐较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++中的定义是一种特殊的函数，它的具体实现由其派生类根据自身的需要进行重写，以实现多态特性。
而纯虚函数是其在进一步抽象程度上的体现，其实现方式不同于虚函数，但在实现多态时发挥了重要作用，也为C++程序员在面向对象编程中提供了更多的编程方式。
在这篇文章中，我们将讨论纯虚函数的实现、调用方式以及其在代码开发中的应用场景。
一、纯虚函数的概念和定义纯虚函数是由virtual修饰的函数，用于在基类中定义一种接口规范，将具体的实现留给其派生类去完成。
在C++程序设计中，我们使用纯虚函数，目的是为了实现抽象类，从而在程序中实现多态。
纯虚函数同样也是一种虚函数，只是在其函数定义中添加了＝0的标记。
它的函数声明与虚函数类似，但是不需要提供函数体。
具体的定义如下：class A{public:virtual void func() = 0; //纯虚函数，定义接口规范};在基类A中，只定义了函数的接口规范(func函数)，而具体的实现将留给其派生类来完成。
与一般的虚函数不同的是，在纯虚函数定义中，我们可以通过赋值符号＝0来将其标记为纯虚函数，也就是说，纯虚函数是没有具体的实现的，其派生类必须实现该函数。
因此，我们在程序中使用纯虚函数时，需要在该函数的派生类中对其进行重写，定义具体实现，否则编译器将报错。
二、纯虚函数的调用纯虚函数不能直接被调用。
这意味着，如果在程序中直接实例化基类中的纯虚函数，编译器将会报错。
因为纯虚函数没有具体实现，同时也没有虚函数表。
此时，我们必须使用其指针或引用来调用纯虚函数。
接下来，我们通过代码来演示一下纯虚函数如何被调用。
class A{public:virtual void func() = 0; //纯虚函数，定义接口规范};class B : public A{public:void func() override{std::cout << "function B" << std::endl;}};int main(){A* pA = new B; //父类指针指向派生类对象pA->func(); //通过父类指针调用纯虚函数return 0;}在上面的代码中，我们定义了两个类A和B，其中A类是一个抽象类，拥有一个纯虚函数func()。
虚函数和纯虚函数的作用与区别
class A{
protected:
void foo();//普通类函数
virtual void foo1();//虚函数
virtual void foo2() = 0;//纯虚函数
}
观点二：
虚函数在子类里面也可以不重载的；但纯虚必须在子类去实现，这就像Java的接口一样。通常我们把很多函数加上virtual，是一个好的习惯，虽然牺牲了一些性能，但是增加了面向对象的多态性，因为你很难预料到父类里面的这个函数不在子类里面不去修改它的实现
虚函数和纯虚函数的作用与区别
虚函数为了重载和多态的需要，在基类中是由定义的，即便定义是空，所以子类中可以重写也可以不写基类中的函数！
纯虚函数在基类中是没有定义的，必须在子类中加以实现，很像java中的接口函数！
虚函数
引入原因：为了方便使用多态特性，我们常常需要在基类中定义虚函数。
class Cman
{
public:
virtual void Eat(){……};
void Move();
private:
};
class CChild : public CMan
{
public:
virtual void Eat(){……};
private:
};
CMan m_man;
CChild m_child;
//这才是使用的精髓，如果不定义基类的指针去使用，没有太大的意义
//建筑公司就可以按照你的方法去实现了，如果你不说清楚这些，可能建筑
//公司不太了解你需要楼房的特性。用纯需函数就可以很好的分工合作了
虚函数和纯虚函数区别
抽象类与纯虚函数
纯虚函数和抽象类:含有纯虚函数的类是抽象类，不能生成对象，只能派生。
他派生的类的纯虚函数没有被改写，那么，它的派生类还是个抽象类。
定义纯虚函数就是为了让基类不可实例化化,因为实例化这样的抽象数据结构本身并没有意义.或者给出实现也没有意义一. 纯虚函数在许多情况下，在基类中不能给出有意义的虚函数定义，这时可以把它说明成纯虚函数，把它的定义留给派生类来做。
定义纯虚函数的一般形式为：class 类名{virtual 返回值类型函数名（参数表）= 0; // 后面的"= 0"是必须的，否则，就成虚函数了};纯虚函数是一个在基类中说明的虚函数，它在基类中没有定义，要求任何派生类都定义自己的版本。
纯虚函数为各派生类提供一个公共界面。
从基类继承来的纯虚函数，在派生类中仍是虚函数。
二. 抽象类1. 如果一个类中至少有一个纯虚函数，那么这个类被称为抽象类（abstract class）。
抽象类中不仅包括纯虚函数，也可包括虚函数。
抽象类中的纯虚函数可能是在抽象类中定义的，也可能是从它的抽象基类中继承下来且重定义的。
2. 抽象类特点，即抽象类必须用作派生其他类的基类，而不能用于直接创建对象实例。
一个抽象类不可以用来创建对象，只能用来为派生类提供一个接口规范，派生类中必须重载基类中的纯虚函数，否则它仍将被看作一个抽象类。
3. 在effective c++上中提到，纯虚函数可以被实现（定义），但是，不能创建对象实例，这也体现了抽象类的概念。
三. 虚析构函数虚析构函数: 在析构函数前面加上关键字virtual进行说明，称该析构函数为虚析构函数。
虽然构造函数不能被声明为虚函数，但析构函数可以被声明为虚函数。
一般来说，如果一个类中定义了虚函数，析构函数也应该定义为虚析构函数。
例如：class B{virtual ~B(); //虚析构函数…};关于更多的精彩解释，请参考<< c++编程思想 >> 一书。
虚函数与纯虚函数的区别
虚函数与纯虚函数的区别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. 多态性指相同对象收到不同消息或不同对象收到相同消息时产⽣不同的实现动作。
纯函数和虚函数
纯函数和虚函数
纯函数和虚函数是计算机编程中常用的两种函数。
纯函数指的是没有副作用且输入相同输出也相同的函数，常见的纯函数包括数学函数和字符串处理函数；而虚函数则是面向对象程序设计中的概念，指的是可以被重写的成员函数。
纯函数的特点是输入和输出之间没有任何关联，不会对程序状态进行任何改变，也不会引起任何副作用。
由于纯函数的输出只与输入有关，因此也被称为具有“引用透明性”的函数，方便代码的测试和调试。
虚函数则是一种在面向对象程序设计中特别常见的概念。
它允许派生类重写基类中的函数，在派生类中实现不同的行为。
虚函数的实现方式是使用虚函数表，将函数调用与具体实现分离，提高代码的可维护性和扩展性。
需要注意的是，虚函数和纯函数是不同的概念，虚函数可以是纯虚函数也可以是非纯虚函数，纯函数则不涉及面向对象程序设计的概念。
在编写程序时，需要根据具体应用场景选择使用纯函数或虚函数，以提高程序的效率和可维护性。
- 1 -。
纯函数与虚函数
纯函数与虚函数简介在计算机编程中，纯函数（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++之普通成员函数、虚函数以及纯虚函数的区别与用法要点
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就是⼀个普通的函数。
纯虚函数的作用
纯虚函数的作用纯虚函数是一种让子类继承的特殊函数，也叫虚函数。
它们没有函数实现，只有虚函数声明。
纯虚函数可以实现多态性，是对象多态性的基础。
纯虚函数将类绑定到基类，它们之间具有一种特殊的联系，即派生类必须实现所有的虚拟函数。
也就是说，如果一个类有一个或多个纯虚函数，那么该类就是一个抽象类，不能够实例化对象。
另外，如果一个子类是从一个抽象类继承的，则必须实现其父类的所有纯虚函数。
纯虚函数的最大特点是它们可以实现多态性，它通过允许在不同类中实现同一个接口来实现多态性。
这意味着，如果一个类有一个或多个纯虚函数，那么可以使用任何子类来实现这些函数，而不必担心其他的类。
例如，有一个基类Shape，它有一个纯虚函数calculateArea，那么可以使用Rectangle、Triangle和Circle类来实例化对象并实现calculateArea函数，而不必担心与其他类的交互。
多态性可以帮助程序员更好地管理它们的代码。
例如，如果你有一组可以作为参数传递的类型，你可以避免判断类别并实施不同操作的if/else代码，而是使用多态性，只需要一种共同的接口来管理隐藏内部实现细节。
纯虚函数也有一定的局限性，它们不能定义访问修饰符，比如public、protected或private，只有“virtual”和“pure virtual”修饰符。
此外，在抽象类中，只能存在纯虚函数，并且抽象类不能实例化对象，因为它的纯虚函数没有被实现。
总的来说，纯虚函数是一种很实用的特性，有助于提高代码的可扩展性。
它能够实现多态性，帮助我们更好地管理复杂的代码，并避免无用的if/else代码。
但是，它也有一定的局限性，比如不能使用其他访问修饰符，只能在抽象类中使用，并且抽象类不能实例化对象。
虚函数
运行结果： P1.area()=0 C1.area()=1256.64 Pp->area()=1256.64 Rp.area()=1256.64
第 9 章
多 态 性
程序解释： 程序16行在基类Point中，将area()声明为虚函数。 第39通过Point类对象P1调用虚函数area()。 第41通过circle类对象C1调用area()，实现静态联编，调用的是Circle类area()。 第44、46行分别通过Point类型指针与引用调用area()，由于area()为虚函数，此 时进行动态联编，调用的是实际指向对象的area()。
第 9 章
多 态 性
Pp->area()=0 Rp.area()=0
C + + 语 言 程 序 设 计 教 程
9.3.1 静态联编与动态联编
程序解释：
程序39行调用P1.area()显示了Point类对象P1的面积； 程序41行通过调用C1.area() 显示了Circle类对象C1的面积；由于在类Circle中重新定义了area(), 它覆盖了基类的 area(), 故通过C1.area()调用的是类Circle中的area(), 返回了正确结果。 依照类的兼容性，程序43行用一个point型的指针指向了Circle类的对象C1, 第44行通 过Pp->area()调用area(), 那么究竟调用的是哪个area(), C++此时实行静态联编，根据 Pp的类型为Point型，将从Point类中继承来的area()绑定给Pp, 因此，此时调用的是 Point派生的area(), 显示的结果为0。 同样，在第46行由引用Rp调用area()时，也进行静态联编，调用的是Point派生的 area(), 显示的结果为0。 显然，静态联编盲目根据指针和引用的类型而不是根据实际指向的目标确定调用的 函数，导致了错误。 动态联编则在程序运行的过程中，根据指针与引用实际指向的目标调用对应的函数 ，也就是在程序运行时才决定如何动作。虚函数（virtual function）允许函数调用与函 数体之间的联系在运行时才建立，是实现动态联编的基础。虚函数经过派生之后，可以 在类族中实现运行时的多态，充分体现了面向对象程序设计的动态多态性。
c++ 基类纯虚函数
c++ 基类纯虚函数C++是一种广泛使用的编程语言，同时也是面向对象编程语言。
在C++中，一个类可以从另一个类继承，这个类被称为基类，而继承的类被称为派生类。
基类中的纯虚函数是C++中非常重要的概念之一，它们在设计类的继承层次结构时非常有用。
纯虚函数是一种在基类中定义的虚函数，它没有任何实现代码，只是为了被继承类实现。
纯虚函数可以用一对`virtual`和`= 0`来声明，例如：```virtual void MyFunction() = 0;```这个声明告诉编译器MyFunction是一个虚函数，并且没有实现，只是一个接口，继承类必须对其进行实现。
纯虚函数在基类中起到了规范和约束作用，因为派生类必须实现这个函数才能实现自己的功能。
在许多情况下，基类中的纯虚函数是被设计为通用算法，由派生类提供特定的实现。
这种方法被称为“模板方法”模式。
在一个简单的图形库中，我们可以定义一个基类Shape，这个基类包含一个纯虚函数`Draw()`和派生类Rectangle和Circle。
Rectangle和Circle分别提供它们自己的特殊化实现，Draw()方法则会被调用以完成具体的实际操作。
在C++中，派生类中的实现方法可以通过覆盖和重载来完成。
覆盖是指派生类重新定义基类中的虚函数，以提供不同的实现方法。
重载是指派生类定义具有相同名称的函数，但它们具有不同的参数列表，这使得可以在相同的类中实现两个或更多的函数。
在实际开发中，如果我们定义了一个纯虚函数但没有提供实现，那么它将无法被实例化，因为它是一个抽象的函数。
通常情况下，如果我们忘记实现这个函数，可能会在编译时收到一个错误消息。
在设计一个类的继承时，纯虚函数是一种非常有用的技术。
它可以帮助我们将代码和数据聚集在一起，以便更好地组织和管理。
纯虚函数还可以使我们更迅速和简单地实现代码的重用和复用。
在C++中，基类中的纯虚函数是非常重要的。
它们可以帮助我们在类的继承层次结构中实现一些非常有用的功能，例如模板方法和多态。
C++中虚函数和纯虚函数的区别与总结
C++中虚函数和纯虚函数的区别与总结⾸先：强调⼀个概念定义⼀个函数为虚函数，不代表函数为不被实现的函数。
定义他为虚函数是为了允许⽤基类的指针来调⽤⼦类的这个函数。
定义⼀个函数为纯虚函数，才代表函数没有被实现。
定义纯虚函数是为了实现⼀个接⼝，起到⼀个规范的作⽤，规范继承这个类的程序员必须实现这个函数。
1、简介假设我们有下⾯的类层次：class A{public:virtual void foo(){cout<<"A::foo() is called"<<endl;}};class B:public A{public:void foo(){cout<<"B::foo() is called"<<endl;}};int main(void){A *a = new B();a->foo(); // 在这⾥，a虽然是指向A的指针，但是被调⽤的函数(foo)却是B的!return 0;}这个例⼦是虚函数的⼀个典型应⽤，通过这个例⼦，也许你就对虚函数有了⼀些概念。
它虚就虚在所谓“推迟联编”或者“动态联编”上，⼀个类函数的调⽤并不是在编译时刻被确定的，⽽是在运⾏时刻被确定的。
由于编写代码的时候并不能确定被调⽤的是基类的函数还是哪个派⽣类的函数，所以被成为“虚”函数。
虚函数只能借助于指针或者引⽤来达到多态的效果。
C++纯虚函数⼀、定义 纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派⽣类都要定义⾃⼰的实现⽅法。
在基类中实现纯虚函数的⽅法是在函数原型后加“=0”virtual void funtion1()=0⼆、引⼊原因1. 为了⽅便使⽤多态特性，我们常常需要在基类中定义虚拟函数。
2. 在很多情况下，基类本⾝⽣成对象是不合情理的。
例如，动物作为⼀个基类可以派⽣出⽼虎、孔雀等⼦类，但动物本⾝⽣成对象明显不合常理。
c++ 纯虚函数定义和使用方法
下面是一个完整的示例，展示了纯虚函数的定义和使用方法：
cpp复制代码
#include<iostream>
classBase{
public:
virtualvoidmyFunction()=0;//纯虚函数
};
classDerived:publicBase {
public:
voidmyFunction()override{
std::cout <<"Derived class implementation"<< std::endl;
}
};
intmain(){
Base* ptr =newDerived();
ptr->myFunction();//调用派生类的函数
deleteptr;
return0;
}
在上面unction()函数是纯虚函数。Derived类继承自Base类并实现了myFunction()函数。在main()函数中，通过基类指针ptr调用了派生类的函数，实现了多态性。输出结果为"Derived class implementation"。
cpp复制代码
voidDerived::myFunction(){
//具体的实现代码
}
3.使用纯虚函数：通过基类的指针或引用，可以调用派生类中实现的纯虚函数。这样可以实现多态性，即在运行时确定调用的是哪个派生类的函数。例如：
cpp复制代码
Base* ptr =newDerived();
ptr->myFunction();//调用派生类的函数
python 纯虚函数
python 纯虚函数Python中没有纯虚函数的概念，因为Python是一种动态类型语言，所以不需要使用纯虚函数来实现多态性。
在Python中，可以使用抽象基类(ABC)来定义接口，强制实现其子类中的一些方法。
抽象基类是一个只包含抽象方法的类，不能直接实例化，只能通过其子类来实现。
使用抽象基类可以使代码更加清晰易懂，并且提高代码的可维护性和可扩展性。
例如，以下是一个使用抽象基类实现接口的示例： ```pythonfrom abc import ABC, abstractmethodclass Shape(ABC):@abstractmethoddef area(self):passclass Rectangle(Shape):def __init__(self, length, width):self.length = lengthself.width = widthdef area(self):return self.length * self.widthclass Circle(Shape):def __init__(self, radius):self.radius = radiusdef area(self):return 3.14 * self.radius ** 2r = Rectangle(10, 5)print('Rectangle area:', r.area())c = Circle(5)print('Circle area:', c.area())```在上面的代码中，我们定义了一个抽象基类`Shape`，其中包含一个抽象方法`area()`，用于计算形状的面积。
然后我们定义了两个具体的子类`Rectangle`和`Circle`，分别实现了`area()`方法来计算矩形和圆形的面积。
通过使用抽象基类，我们强制子类实现`area()`方法，并确保了代码的一致性和可读性。
虚函数和纯虚函数的作用与区别
虚函数和纯虚函数的作用与区别1.虚函数的作用：虚函数是在基类中被声明为虚函数的成员函数，它允许在派生类中进行函数重写，实现运行时多态。
虚函数的作用包括：1)实现运行时多态：由于基类指针可以指向派生类对象，通过调用虚函数，可以根据实际对象类型来确定调用哪个函数，实现动态绑定。
2)代码重用：通过将函数定义在基类中，所有派生类都可以直接继承该函数，避免重复编写相同代码。
2.纯虚函数的作用：纯虚函数是在基类中没有给出实现的虚函数，它的目的是为了定义接口，并强制派生类实现该接口。
纯虚函数的作用包括：1)定义接口：纯虚函数在基类中只有函数的声明，派生类必须实现该纯虚函数来完成基类定义的接口。
2)实现动态绑定：通过将纯虚函数定义为虚函数，可实现基类指针指向派生类对象时，根据对象类型动态绑定相应的函数。
3.区别：1)实现方式：虚函数在基类中有函数的实现，但允许在派生类中进行重写；纯虚函数在基类中只有函数的声明，没有具体的实现。
2)调用方式：虚函数通过基类指针或引用来调用，根据实际对象类型动态绑定相应函数；纯虚函数通过基类指针或引用来调用时，必须在派生类中实现该函数。
3)对派生类的要求：包含纯虚函数的类被称为抽象类，无法实例化对象，只能作为基类使用。
派生类必须实现基类的纯虚函数才能被实例化。
综上所述，虚函数和纯虚函数在实现多态和抽象类方面都有重要作用。
虚函数通过动态绑定机制实现运行时多态和代码重用；纯虚函数则用于定义接口，并要求派生类实现该接口。
虚函数在基类中有实现，在派生类中可以进行重写；而纯虚函数只有声明，在派生类中必须实现。
同时，包含纯虚函数的类无法实例化，只能作为基类使用。
了解虚函数和纯虚函数的作用及区别，有助于我们更好地理解和应用面向对象编程的概念和技术。
纯虚函数和虚函数
纯虚函数和虚函数虚函数和纯虚函数都是面向对象编程语言中重要的概念，它们的应用可以大大提高代码的复用率、可维护性和可扩展性。
下面我们就来分步骤阐述这两种函数的相关知识。
1. 虚函数：虚函数是类中定义的声明为虚函数的成员函数。
它允许在子类中重写它，而且允许在程序运行时根据对象实际类型来调用。
举个例子，假如我们有一个图形类 Shape 和一个子类 Rectangle。
其中 Shape类中有一个虚函数 area()，用于计算图形的面积。
而Rectangle 类中则继承了 Shape 类，并重写了它的 area() 函数，计算长方形的面积。
虚函数的声明方式为：virtual returnType functionName();其中 returnType 表示函数的返回值类型，functionName 表示函数名。
2. 纯虚函数：纯虚函数是将虚函数定义为纯虚函数，即在函数后面加上 = 0. 它的作用是定义接口而不实现接口，在子类中必须被实现才能构造对象，否则会报错。
继续以上面的例子说明，假如我们定义一个含有纯虚函数的 Shape 类，它的 area() 函数就可以定义成纯虚函数，以下面的方式声明：virtual returnType functionName() = 0;此时，Rectangle 类就必须重写 area() 函数，否则编译器将无法通过它的构造函数。
3. 虚函数和纯虚函数的区别：虚函数有默认的实现，而纯虚函数没有默认的实现。
因此，派生类必须实现纯虚函数。
此外，虚函数可以在基类中实现，在派生类中重写，而纯虚函数只能在派生类中实现。
4. 使用场合：虚函数和纯虚函数在实际应用中都有着广泛的应用。
虚函数适合在基类中提供默认实现，而允许在必要时在派生类中被重写。
而纯虚函数适用于需要提供一套公共接口的情况，但是它们的具体实现却在各自的派生类中。
5. 总结：虚函数和纯虚函数是面向对象编程语言中非常重要的概念，它们的应用可以优化代码的结构和可重用性。
纯虚函数 函数体
纯虚函数函数体纯虚函数是在基类中声明的虚函数，但没有提供函数体的函数。
纯虚函数的声明使用"=0" 运算符来指示。
纯虚函数必须在派生类中重写，并且提供函数体。
纯虚函数通常用于定义接口，而不需要在基类中提供函数实现。
它们可以被派生类实现，以满足它们自己的特定需求。
以下是一个示例：cppclass Shape {public:virtual void draw() = 0; 纯虚函数};class Circle : public Shape {public:void draw() {提供函数体的实现绘制一个圆形}};class Square : public Shape {public:void draw() {提供函数体的实现绘制一个正方形}};在上面的示例中，Shape 是一个抽象类，它包含一个纯虚函数draw()。
Circle 和Square 是派生类，它们必须重写draw() 函数并提供自己的实现。
请注意，纯虚函数是可以有函数体的。
例如，我们可以在Shape 类中为draw() 函数提供一个默认的空函数体：cppclass Shape {public:virtual void draw() = 0; 纯虚函数virtual ~Shape() {} 虚析构函数};void Shape::draw() {默认的空函数体}这样做的好处是，派生类可以选择是否重写draw() 函数，如果不重写，则将使用基类中的默认实现。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
纯虚函数空函数
一、纯虚函数
纯虚函数是指在基类中声明但没有定义的虚函数，它的作用是为派生类提供一个接口，派生类必须实现这个函数。
纯虚函数的声明语法为：
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.代码兼容性。
空函数可以提高代码的兼容性，当代码需要调用某个函数时，即使函数还未完成，也可以使用空函数来代替。
空函数的应用场景：
2.占位符。
在实现类似回调函数的功能时，需要先声明一个函数指针，但函数指针还未指向实际的函数。
此时可以使用空函数来占据函数指针的位置。
我们可以在我们的程序中定义一个空函数，当程序需要打印一些信息时，可以调用该函数。
代码如下：
void printMessage(){}
以上程序不会执行任何操作，但会输出一条消息，结果如下：
This is a message.
总结：进一步探究纯虚函数和空函数的相关内容，需要了解它们在实际开发中的应用。
在具体实践中，我们经常需要使用抽象类和接口来实现程序的设计，并使用纯虚函数来规
范子类的实现。
空函数在代码开发过程中也经常被使用到。
下面我们将对这些方面进行更
加深入的讨论。
一、抽象类和接口
抽象类通常定义有纯虚函数，不能被实例化，但可以作为其他类的基类。
由于抽象类
只规定了接口而没有实际的实现代码，因此不能直接被使用。
需要先创建它的子类，并实
现其中的纯虚函数，才能被实例化。
接口是一种固定模式的规范，它规定了类的公共行为和能力，可以由多个类实现。
接
口中定义了纯虚函数，它们只规范行为，不包括任何实现。
类实现了接口后，必须实现该
接口中的所有纯虚函数。
二、纯虚函数和多态性
纯虚函数在实际开发中经常用于实现多态性，它可以让派生类继承并重新定义父类的
函数，从而实现子类对象调用不同函数的效果。
多态性通常可以分为两种：静态多态性和
动态多态性。
静态多态性是指编译器在编译时根据类型决定调用哪个函数。
在使用多态性中，通常
会使用基类指针或引用指向派生类对象，当调用基类指针或引用的函数时，实际上调用的
是派生类重载后的函数。
动态多态性是指编译器在运行时才知道要调用哪个函数。
在C++中，当基类中有纯虚
函数时，任何派生类都必须实现它，在程序运行时可以动态地判断派生类向基类转换的类型，从而达到多态性的目的。
三、空函数的应用
空函数在代码开发过程中经常用于占位或在后续开发中替换为有用的函数。
一般情况下，当代码需要调用某个函数时，即使函数还未完成，也可以使用空函数来代替。
这在大型、复杂的项目中特别有效，因为它允许多个程序员分别开发代码，当未完成的代码需要
调用时，使用空函数来占据它的位置。
空函数还可以在调试和单元测试过程中使用。
当某个函数还未完成时，我们可以使用
空函数来代替，以保证代码的正常运行。
特别是在程序的某些重要功能有问题时，空函数
也可以用作调试器的桩函数。
这样可以轻松地设置断点和追踪调试器，以帮助发现问题并
进行修复。
四、总结
本文介绍了纯虚函数和空函数在面向对象编程中的应用，以及它们在实际开发中的作用。
了解纯虚函数和空函数的特点和应用，可以帮助开发人员更好地理解和掌握OOP的概念和实践。
掌握好纯虚函数和空函数的使用方法，可以有效地提高代码的可读性和可维护性，有助于开发高质量的软件。