实验三虚函数与多态纯虚函数(完全版)

一．实验目的及要求1．进一步熟悉类的设计、运用继承与派生机制设计派生类，合理设置数据成员和成员函数。

2．掌握通过继承、虚函数、基类的指针或引用实现动态多态性的方法。

3．理解并掌握具有纯虚函数的抽象类的作用，在各派生类中重新定义各纯虚函数的方法，以及此时实现的动态多态性。

二．实验内容在自己的文件夹下建立一个名为exp5的工程，在该工程中做如下操作：定义一个抽象类容器类，其中定义了若干纯虚函数，实现求表面积、体积、输出等功能。

由此抽象类派生出正方体、球体和圆柱体等多个派生类，根据需要定义自己的成员变量，在各个派生类中重新定义各纯虚函数，实现各自类中相应功能，各个类成员的初始化均由本类构造函数实现。

（1）在主函数中，定义容器类的指针和各个派生类的对象，使指针指向不同对象处调用相同的函数能执行不同的函数代码，从而实现动态多态性。

（2）定义一个顶层函数void TopPrint(Container &r);使得主函数中调用该函数时，根据实在参数所有的类自动调用对应类的输出函数。

（3）主函数中定义一个Container类对象，观察编译时的错误信息，从而得出什么结论三．实验程序及运行结果#include <iostream>using namespace std;class Base{public:virtual void f(){ cout << "调用Base::f()" << endl; }};class Derived: public Base{public:void f(){ cout << "调用Derived::f()" << endl; } // 虚函数};int main(void){Derived obj; // 定义派生类对象Base *p = &obj; // 基类指针p->f(); // 调用函数f()system("PAUSE");return 0;}2.#include <iostream>using namespace std; //class Base{public:virtual void Show() const{ cout << "调用Base::Show()" << endl; } // 虚函数};class Derived: public Base{public:void Show() const{ cout << "调用Derived::Show()" << endl; }};void Refers(const Base &obj) // 基类引用{obj.Show(); // 调用函数Show()}int main(void){Base obj1;Derived obj2; // 定义对象Refers(obj1); // 调用函数Refers()Refers(obj2);system("PAUSE");return 0;}3.#include <iostream>using namespace std; /class Base{private:int m;public:Base(int a): m(a){ }virtual void Show() const{ cout << m << endl; }// 虚函数};class Derived: public Base{private:int n;public:Derived(int a, int b): Base(a), n(a){ } // 构造函数void Show() const{cout << n << ","; /Base::Show(); // 调用基类的Show() }};int main(void){Base obj1(168);Derived obj2(158, 98);Base *p;p = &obj1;p->Show();p = &obj2;p->Show();p->Base::Show();system("PAUSE");return 0;}4.#include <iostream>using namespace std;class A{public:virtual void Show() const{ cout << "基类A" << endl; } };class B: public A{public:void Show() const{ cout << "派生类B" << endl; } };int main(void){B obj;A *p = &obj;p->Show();system("PAUSE");return 0;}5.#include <iostream>using namespace std;const double PI = 3.1415926;class Shape{public:virtual void Show() const = 0;static double sum;};class Circle: public Shape{private:double radius;public:Circle(double r): radius(r){ sum += PI * radius * radius; }void Show() const{cout << "圆形:" << endl;cout << "半径:" << radius << endl;cout << "面积:" << PI * radius * radius << endl;}};class Rectangle: public Shape{private:double height;double width;public:Rectangle(double h, double w): height(h), width(w){ sum += height * width; }void Show() const{cout << "矩形:" << endl;cout << "高:" << height << endl;cout << "宽:" << width << endl;cout << "面积:" << height * width << endl;}};double Shape::sum = 0;int main(void){char flag = 'Y'; 'Shape *p;while (toupper(flag) == 'Y'){cout << "请选择输入类别(1.圆形2.矩形)";int select;cin >> select;switch (select){case 1:double r;cout << "输入半径:";cin >> r;p = new Circle(r);p->Show();delete p;break;case 2:double h, w;cout << "输入高:";cin >> h;cout << "输入宽:";cin >> w;p = new Rectangle(h, w);p->Show(); // 显示相关信息delete p; // 释放存储空间break;default: // 其它情况, 表示选择有误cout << "选择有误!"<< endl;break;}cout << endl << "是否继续录入信息?(Y/N)";cin >> flag;}cout << "总面积:" << Shape::sum << endl;system("PAUSE");return 0;}6.#include <iostream>using namespace std;const double PI = 3.1415926;const int NUM = 10;class Shape{public:virtual void ShowArea() const = 0;static double sum;};class Circle: public Shape{private:double radius;public:Circle(double r): radius(r){ sum += PI * radius * radius; }void ShowArea() const{ cout << "圆面积:" << PI * radius * radius << endl; }};class Rectangle: public Shape{private:double height;double width;public:Rectangle(double h, double w): height(h), width(w){ sum += height * width; }void ShowArea() const{ cout << "矩形面积:" << height * width << endl; }};class Square: public Shape{private:double length;public:Square(double a): length(a){ sum += length * length; }void ShowArea() const{ cout << "正方形面积:" <<length * length << endl; } };double Shape::sum = 0;int main(void){Shape *shape[NUM];int count = 0;while (count < NUM){cout << "请选择(1.圆形2.矩形3.正方形4.退出):";int select;cin >> select;if (select == 4) break;switch (select){case 1:double r;cout << "输入半径:";cin >> r;shape[count] = new Circle(r);shape[count]->ShowArea();count++;break;case 2:double h, w;cout << "输入高:";cin >> h;cout << "输入宽:";cin >> w;shape[count] = new Rectangle(h, w);shape[count]->ShowArea();count++;break;case 3:double a;cout << "输入边长:";cin >> a;shape[count] = new Square(a);shape[count]->ShowArea();count++;break;default:cout << "选择有误!"<< endl;break;}}cout << "总面积:" << Shape::sum << endl;for (int i = 0; i < count; i++) delete shape[i];system("PAUSE");return 0;}五．实验总结通过本次试验 我更深刻的理解了某些语句如何使用及结构体的优点 也能更加熟练的编写简单的程序了 我深知实践要比书本更加重要 今后还要多练习 在实践中学习。

虚函数定义虚函数必须是基类的非静态成员函数，其访问权限可以是protected或public，在基类的类定义中定义虚函数的一般形式：virtual 函数返回值类型虚函数名（形参表）{ 函数体}作用虚函数的作用是实现动态联编，也就是在程序的运行阶段动态地选择合适的成员函数，在定义了虚函数后，可以在基类的派生类中对虚函数重新定义，在派生类中重新定义的函数应与虚函数具有相同的形参个数和形参类型。

以实现统一的接口，不同定义过程。

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

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

动态联编规定，只能通过指向基类的指针或基类对象的引用来调用虚函数，其格式：指向基类的指针变量名->虚函数名（实参表）或基类对象的引用名. 虚函数名（实参表）虚函数是C++多态的一种表现例如：子类继承了父类的一个函数（方法），而我们把父类的指针指向子类，则必须把父类的该函数（方法）设为virturl（虚函数)。

使用虚函数，我们可以灵活的进行动态绑定，当然是以一定的开销为代价。

如果父类的函数（方法）根本没有必要或者无法实现，完全要依赖子类去实现的话，可以把此函数（方法）设为virturl 函数名=0 我们把这样的函数（方法）称为纯虚函数。

如果一个类包含了纯虚函数，称此类为抽象类。

示例虚函数的实例：#include<iostream.h>class Cshape{public:void SetColor( int color) { m_nColor=color;}void virtual Display( void) { cout<<"Cshape"<<endl; }private:int m_nColor;};class Crectangle: public Cshape{public:void virtual Display( void) { cout<<"Crectangle"<<endl; } };class Ctriangle: public Cshape{void virtual Display( void) { cout<<"Ctriangle"<<endl; }};class Cellipse :public Cshape{public: void virtual Display(void) { cout<<"Cellipse"<<endl;} };void main(){Cshape obShape;Cellipse obEllipse;Ctriangle obTriangle;Crectangle obRectangle;Cshape * pShape[4]=for( int I= 0; I< 4; I++)pShape[I]->Display( );}本程序运行结果：CshapeCellipseCtriangleCrectangle所以，从以上程序分析，实现动态联编需要三个条件：1、必须把动态联编的行为定义为类的虚函数。

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

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

本⽂就这两种⽅法进⾏分析以及⽐较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;}分析：可以看出利⽤虚函数可以实现多态，也就是说实现了通过不同对象的接⼝实现了不同的功能。

多态性与虚函数实验报告实验目的：通过实验掌握多态性和虚函数的概念及使用方法，理解多态性实现原理和虚函数的应用场景。

实验原理：1.多态性：多态性是指在面向对象编程中，同一种行为或者方法可以具有多种不同形态的能力。

它是面向对象编程的核心特性之一，能够提供更加灵活和可扩展的代码结构。

多态性主要通过继承和接口来实现。

继承是指子类可以重写父类的方法，实现自己的特定行为；接口是一种约束，定义了类应该实现的方法和属性。

2.虚函数：虚函数是在基类中声明的函数，它可以在派生类中被重新定义，以实现多态性。

在类的成员函数前面加上virtual关键字，就可以将它定义为虚函数。

当使用基类指针或引用调用虚函数时，实际调用的是派生类的重写函数。

实验步骤：1. 创建一个基类Shape，包含两个成员变量color和area，并声明一个虚函数printArea(用于打印面积。

2. 创建三个派生类Circle、Rectangle和Triangle，分别继承Shape类，并重写printArea(函数。

3. 在主函数中，通过基类指针分别指向派生类的对象，并调用printArea(函数，观察多态性的效果。

实验结果与分析：在实验中，通过创建Shape类和派生类Circle、Rectangle和Triangle，可以实现对不同形状图形面积的计算和打印。

当使用基类指针调用printArea(函数时，实际调用的是派生类的重写函数，而不是基类的函数。

这就是多态性的实现，通过基类指针或引用，能够调用不同对象的同名函数，实现了对不同对象的统一操作。

通过实验1.提高代码的可扩展性和灵活性：通过多态性，可以将一类具有相似功能的对象统一管理，节省了代码的重复编写和修改成本，增强了代码的可扩展性和灵活性。

2.简化代码结构：通过虚函数，可以将各个派生类的不同行为统一命名为同一个函数，简化了代码结构，提高了代码的可读性和维护性。

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. 多态性指相同对象收到不同消息或不同对象收到相同消息时产⽣不同的实现动作。

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

纯虚函数的声明语法为：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++程序设计(二)》题目：多态性和虚函数班级：学号：姓名：评语：成绩：指导教师：批阅时间：年月日 C++程序设计实验报告1、实验内容或题目（1）声明二维坐标类作为基类派生圆的类，把派生类圆作为基类，派生圆柱体类。

其中，基类二维坐标类有成员数据：x、y坐标值；有成员函数：构造函数实现对基类成员数据的初始化、输出的成员函数，要求输出坐标位置。

派生类圆类有新增成员数据：半径（R）；有成员函数：构造函数实现对成员数据的初始化、计算圆面积的成员函数、输出半径的成员函数。

派生圆柱体类新增数据有高（H）；新增成员函数有：构造函数、计算圆柱体体积的函数和输出所有成员的函数。

请完成程序代码的编写、调试。

（2）教材393页7－8题。

（3）教材416页1、4、5题。

2、实验目的与要求（1）理解继承与派生的概念（2）掌握通过继承派生出一个新的类的方法（3）了解多态性的概念（4）了解虚函数的作用与使用方法3、实验步骤与源程序⑴ 实验步骤先定义一个基类point，及其成员函数，然后以public的继承方式定义子类circle，再定义一个派生类cylinder，最后在main主函数中定义类对象，调用函数实现其功能。

先定义一个基类A及其重载的构造函数,然后以Public派生出子类B，再定义其构造函数,最后在main主函数中定义类对象，调用成员函数实现其功能。

⑵ 源代码1.#include class Point { public:Point(float=0,float=0); void setPoint(float,float); float getX() const {return x;}C++程序设计实验报告float getY() const {return y;}friend ostream & operator<protected: };Point::Point(float a,float b) {x=a;y=b;}void Point::setPoint(float a,float b) {x=a;y=b;}ostream & operator<class Circle:public Point { public:Circle(float x=0,float y=0,float r=0); void setRadius(float); float getRadius() const; float area () const;friend ostream &operator<protected: };Circle::Circle(float a,float b,float r):Point(a,b),radius(r){}float radius;C++程序设计实验报告void Circle::setRadius(float r) {radius=r;}float Circle::getRadius() const {return radius;}float Circle::area() const {return 3.14159*radius*radius;}ostream &operator<cout<class Cylinder:public Circle { public:Cylinder (float x=0,float y=0,float r=0,float h=0); void setHeight(float); float getHeight() const; float area() const; float volume() const;friend ostream& operator<r=\protected: };Cylinder::Cylinder(float a,float b,float r,floath):Circle(a,b,r),height(h){}float height;C++程序设计实验报告void Cylinder::setHeight(float h){height=h;}float Cylinder::getHeight() const {return height;}float Cylinder::area() const{return 2*Circle::area()+2*3.14159*radius*height;}float Cylinder::volume() const {return Circle::area()*height;}ostream &operator<cout<<int main() {Cylinder cy1(3.5,6.4,5.2,10);cout<感谢您的阅读，祝您生活愉快。

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代码。

但是，它也有一定的局限性，比如不能使用其他访问修饰符，只能在抽象类中使用，并且抽象类不能实例化对象。

C语言虚函数中的特定函数简介C语言是一种面向过程的编程语言，并不直接支持面向对象的概念，其中包括了“类”、“对象”、“继承”等概念。

然而，通过使用一些技巧和设计模式，我们可以在C语言中实现类似于面向对象的功能，其中一个重要的概念就是虚函数。

虚函数是一种特殊的函数，它可以在派生类中被重写，从而实现多态。

虚函数的定义、用途和工作方式是C语言中面向对象编程的重要部分，本文将详细介绍这些内容。

虚函数的定义在C语言中，虚函数的定义需要使用函数指针和结构体实现。

我们可以使用函数指针将一个函数地址赋值给一个结构体中的成员变量，从而形成一个具有特定功能的“方法”。

这样，我们就可以通过这个函数指针来调用结构体中的函数，实现类似于面向对象中对象的方法调用的功能。

下面是一个虚函数的定义示例：typedef struct {void (*function_ptr)(void);} VTable;void function1(void) {printf("This is function1\n");}void function2(void) {printf("This is function2\n");}VTable vtable = {.function_ptr = function1};在上述示例中，我们使用typedef定义了一个VTable结构体，其中有一个function_ptr成员变量，它是一个指向函数的指针。

我们定义了两个函数function1和function2，并分别赋值给了vtable中的function_ptr成员变量。

虚函数的用途虚函数的主要用途是实现多态，使不同类型的对象可以调用相同的接口名称，但执行不同的操作。

通过使用虚函数，我们可以在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++中，定义纯虚函数需要在函数声明后面加上=0，例如：```virtual void func() = 0;```三、纯虚函数的作用1. 接口规范通过定义纯虚函数，可以规范派生类必须实现该接口，从而达到接口规范的目的。

2. 多态性由于纯虚函数没有实现代码，因此无法在基类中直接调用。

但是，在派生类中必须重写该函数并提供具体实现。

这样一来，在使用多态性时就可以通过基类指针或引用调用派生类对象中重写后的该方法。

3. 抽象基类如果一个类中存在至少一个纯虚函数，则该类被称为抽象基类。

抽象基类不能被直接实例化，只能作为其他派生类的基类使用。

四、如何定义一个含有纯虚函数的抽象基类下面是一个含有纯虚函数的抽象基类的定义示例：```class Shape {public:virtual void draw() = 0;};```该类中只有一个纯虚函数draw()，没有具体实现。

五、如何定义派生类并实现纯虚函数下面是一个派生类的定义示例：```class Circle : public Shape {public:void draw() override {// 具体实现代码}};```在Circle类中，必须重写Shape类中的纯虚函数draw()并提供具体实现。

这样一来，在使用多态性时就可以通过Shape类指针或引用调用Circle对象中重写后的该方法。

六、注意事项1. 纯虚函数不能被直接调用，只能作为接口规范使用。

2. 抽象基类不能被直接实例化，只能作为其他派生类的基类使用。

3. 在派生类中重写纯虚函数时，必须使用override关键字进行标识。

4. 如果一个派生类没有重写其继承自基类的所有纯虚函数，则该派生类也成为抽象基类。

虚函数和纯虚函数的作用与区别1.虚函数的作用：虚函数是在基类中被声明为虚函数的成员函数，它允许在派生类中进行函数重写，实现运行时多态。

虚函数的作用包括：1)实现运行时多态：由于基类指针可以指向派生类对象，通过调用虚函数，可以根据实际对象类型来确定调用哪个函数，实现动态绑定。

2)代码重用：通过将函数定义在基类中，所有派生类都可以直接继承该函数，避免重复编写相同代码。

2.纯虚函数的作用：纯虚函数是在基类中没有给出实现的虚函数，它的目的是为了定义接口，并强制派生类实现该接口。

纯虚函数的作用包括：1)定义接口：纯虚函数在基类中只有函数的声明，派生类必须实现该纯虚函数来完成基类定义的接口。

2)实现动态绑定：通过将纯虚函数定义为虚函数，可实现基类指针指向派生类对象时，根据对象类型动态绑定相应的函数。

3.区别：1)实现方式：虚函数在基类中有函数的实现，但允许在派生类中进行重写；纯虚函数在基类中只有函数的声明，没有具体的实现。

2)调用方式：虚函数通过基类指针或引用来调用，根据实际对象类型动态绑定相应函数；纯虚函数通过基类指针或引用来调用时，必须在派生类中实现该函数。

3)对派生类的要求：包含纯虚函数的类被称为抽象类，无法实例化对象，只能作为基类使用。

派生类必须实现基类的纯虚函数才能被实例化。

综上所述，虚函数和纯虚函数在实现多态和抽象类方面都有重要作用。

虚函数通过动态绑定机制实现运行时多态和代码重用；纯虚函数则用于定义接口，并要求派生类实现该接口。

虚函数在基类中有实现，在派生类中可以进行重写；而纯虚函数只有声明，在派生类中必须实现。

同时，包含纯虚函数的类无法实例化，只能作为基类使用。

了解虚函数和纯虚函数的作用及区别，有助于我们更好地理解和应用面向对象编程的概念和技术。

c++实验多态性实验报告C+＋实验多态性实验报告一、实验目的本次实验的主要目的是深入理解和掌握 C+＋中的多态性概念及其实现方式。

通过实际编程和运行代码，体会多态性在面向对象编程中的重要作用，提高编程能力和对 C+＋语言特性的运用水平。

二、实验环境本次实验使用的编程环境为 Visual Studio 2019，操作系统为Windows 10。

三、实验内容（一）虚函数1、定义一个基类｀Shape`，其中包含一个虚函数｀area(）｀用于计算图形的面积。

2、派生类｀Circle` 和｀Rectangle` 分别重写｀area(）｀函数来计算圆形和矩形的面积。

（二）纯虚函数1、定义一个抽象基类｀Vehicle`，其中包含一个纯虚函数｀move(）｀。

2、派生类｀Car` 和｀Bicycle` 分别实现｀move(）｀函数来描述汽车和自行车的移动方式。

（三）动态多态性1、创建一个基类指针数组，分别指向不同的派生类对象。

2、通过基类指针调用虚函数，观察多态性的效果。

四、实验步骤（一）虚函数实现1、定义基类｀Shape` 如下：｀｀｀cppclass Shape ｛public:virtual double area(）＝ 0;｝；｀｀｀2、派生类｀Circle` 的定义及｀area(）｀函数的实现：｀｀｀cppclass Circle ： public Shape ｛private:double radius;public:Circle(double r) ： radius(r) ｛｝double area(）｛return 314 radius radius;｝｝；｀｀｀3、派生类｀Rectangle` 的定义及｀area(）｀函数的实现：｀｀｀cppclass Rectangle ： public Shape ｛private:double length, width;public:Rectangle(double l, double w) ： length(l)， width(w) ｛｝double area(）｛return length width;｝｀｀｀（二）纯虚函数实现1、定义抽象基类｀Vehicle` 如下：｀｀｀cppclass Vehicle ｛public:virtual void move(）＝ 0;｝；｀｀｀2、派生类｀Car` 的定义及｀move(）｀函数的实现：｀｀｀cppclass Car ： public Vehicle ｛public:void move(）｛std:：cout ＜＜＂Car is moving on the road＂＜＜ std:：endl;｝｝；3、派生类｀Bicycle` 的定义及｀move(）｀函数的实现：｀｀｀cppclass Bicycle ： public Vehicle ｛public:void move(）｛std:：cout ＜＜＂Bicycle is moving on the path＂＜＜ std:：endl;｝｝；｀｀｀（三）动态多态性实现1、创建基类指针数组并指向不同的派生类对象：｀｀｀cppShape shapes2;shapes0 ＝ new Circle(50)；shapes1 ＝ new Rectangle(40, 60)；｀｀｀2、通过基类指针调用虚函数：｀｀｀cppfor （int i ＝ 0; i ＜ 2; i+＋）｛std:：cout ＜＜＂Area: ＂＜＜ shapesi>area(）＜＜ std:：endl;｝｀｀｀五、实验结果（一）虚函数实验结果运行程序后，能够正确计算出圆形和矩形的面积，并输出到控制台。

在面向对象的C++语言中，虚函数是一个非常重要的概念。

因为它充分体现了面向对象思想中的继承和多态性这两大特性，在C++语言里应用极广。

比如在微软的MFC类库中，你会发现很多函数都有virtual关键字，也就是说，它们都是虚函数。

难怪有人甚至称虚函数是C++语言的精髓。

那么，什么是虚函数呢，我们先来看看微软的解释：虚函数是指一个类中你希望重载的成员函数，当你用一个基类指针或引用指向一个继承类对象的时候，你调用一个虚函数，实际调用的是继承类的版本。

——摘自MSDN这个定义说得不是很明白。

MSDN中还给出了一个例子，但是它的例子也并不能很好的说明问题。

我们自己编写这样一个例子：#include "stdio.h"#include "conio.h"class Parent{public:char data[20];virtual void Function2; // 这里声明是虚函数}parent;void Parent::Function1{}void Parent::Function2{}class Child:public Parent{} child;{}{}int main(int argc, char* argv){Parent *p; // 定义一个基类指针if(_getch=='c') // 如果输入一个小写字母c p=&child; // 指向继承类对象elsep=&parent; // 否则指向基类对象 // 这里在编译时会直接给出的入口地址。

// 注意这里，执行的是哪一个？return 0;}用任意版本的Visual C++或Borland C++编译并运行，输入一个小写字母c，得到下面的结果：This is parent,function1This is child,function2为什么会有第一行的结果呢？因为我们是用一个Parent类的指针调用函数Fuction1，虽然实际上这个指针指向的是Child类的对象，但编译器无法知道这一事实（直到运行的时候，程序才可以根据用户的输入判断出指针指向的对象），它只能按照调用Parent类的函数来理解并编译，所以我们看到了第一行的结果。

纯虚函数和虚函数虚函数和纯虚函数都是面向对象编程语言中重要的概念，它们的应用可以大大提高代码的复用率、可维护性和可扩展性。

下面我们就来分步骤阐述这两种函数的相关知识。

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. 总结：虚函数和纯虚函数是面向对象编程语言中非常重要的概念，它们的应用可以优化代码的结构和可重用性。