虚函数和纯虚函数

合集下载

纯函数虚函数

纯函数虚函数

纯函数虚函数
纯函数和虚函数是C++语言中重要的概念。

纯函数指的是在函数
体内不使用任何外部变量,且函数的返回值只依赖于输入参数的值,
即不会受到任何其他因素的影响,相同的输入永远会得到相同的输出。

因此,纯函数不会产生任何副作用,也就是说,不会改变外部环境的
状态。

纯函数在并发编程和函数式编程中应用广泛。

虚函数是一种在基类中声明的成员函数,它可以被派生类重新定义。

虚函数通过使用动态绑定,实现在运行时确定调用哪个类的函数。

作为虚函数的重要应用,多态性使得代码更加灵活,可以更好地适应
变化。

在C++中,对于类中的成员函数,可以将其声明为纯函数和虚函数,也可以同时声明为纯虚函数和虚函数。

纯虚函数是指在基类中声
明的函数,但没有给出函数实现,需要在派生类中定义函数实现。


函数和纯虚函数都可以使用override关键字来在派生类中重定义,从
而实现更加灵活的代码结构。

虚,纯虚等的概念

虚,纯虚等的概念

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++虚函数及虚函数表解析

C++虚函数及虚函数表解析

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

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

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

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

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

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

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

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

定义虚函数的限制: (1)⾮类的成员函数不能定义为虚函数,类的成员函数中静态成员函数和构造函数也不能定义为虚函数,但可以将析构函数定义为虚函数。

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

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

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

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

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

纯虚函数调用

纯虚函数调用

纯虚函数调用虚函数在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;
//这才是使用的精髓,如果不定义基类的指针去使用,没有太大的意义
//建筑公司就可以按照你的方法去实现了,如果你不说清楚这些,可能建筑
//公司不太了解你需要楼房的特性。用纯需函数就可以很好的分工合作了
虚函数和纯虚函数区别

虚函数与纯虚函数的区别

虚函数与纯虚函数的区别

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

virtualfree函数的详细用法

virtualfree函数的详细用法

虚函数是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++中还有虚析构函数的概念。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

虚函数和纯虚函数在面向对象的C++语言中,虚函数(virtual function)是一个非常重要的概念。

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

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

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

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

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

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

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

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

那么第二行的结果又是怎么回事呢?我们注意到,Function2()函数在基类中被virtual关键字修饰,也就是说,它是一个虚函数。

虚函数最关键的特点是“动态联编”,它可以在运行时判断指针指向的对象,并自动调用相应的函数。

如果我们在运行上面的程序时任意输入一个非c的字符,结果如下:This is parent,function1This is parent,function2请注意看第二行,它的结果出现了变化。

程序中仅仅调用了一个Function2()函数,却可以根据用户的输入自动决定到底调用基类中的Function2还是继承类中的Function2,这就是虚函数的作用。

我们知道,在MFC中,很多类都是需要你继承的,它们的成员函数很多都要重载,比如编写MFC应用程序最常用的CView::OnDraw(CDC*)函数,就必须重载使用。

把它定义为虚函数(实际上,在MFC中OnDraw不仅是虚函数,还是纯虚函数),可以保证时刻调用的是用户自己编写的OnDraw。

虚函数的重要用途在这里可见一斑。

再看下面的-----------------------------------------------------------摘自:C++中虚函数和纯虚函数的概念,差别和分别存在的原因首先:强调一个概念定义一个函数为虚函数,不代表函数为不被实现的函数定义他为虚函数是为了允许用基类的指针来调用子类的这个函数定义一个函数为纯虚函数,才代表函数没有被实现定义他是为了实现一个接口,起到一个规范的作用,规范继承这个类的程序员必须实现这个函数。

对继承的影响:普通的类(没有虚函数,纯虚函数)就可以被继承,而且工作的相当好关于这个问题有以下疑问:纯虚函数难道就是为了实现接口?接口存在的意义?我实在弄不懂,我干嘛要预先定义好?未来的事情本难料就等有一天我的类中需要使用某个函数,在添加一个函数不久可以?关于实例化一个类:有纯虚函数的类是不可能生成类对象的,如果没有纯虚函数则可以。

比如:class CA{public:virtual void fun() = 0; // 说明fun函数为纯虚函数virtual void fun1();};class CB{public:virtual void fun();virtual void fun1();};// CA,CB类的实现...void main(){CA a; // 不允许,因为类CA中有纯虚函数CB b; // 可以,因为类CB中没有纯虚函数...}---------------------------------------------------------------虚函数在多态中间的使用:多态一般就是通过指向基类的指针来实现的。

dog mydogwangwang;mydogwangwang.born();一定是返回“dog”那么horse myhorsepipi;myhorsepipi.born();一定是返回“horse”也是多态呀?/////////////////////////////////////////////////有一点你必须明白,就是用父类的指针在运行时刻来调用子类:例如,有个函数是这样的:void animal::fun1(animal *maybedog_maybehorse){maybedog_maybehorse->born();}参数maybedog_maybehorse在编译时刻并不知道传进来的是dog类还是horse类,所以就把它设定为animal类,具体到运行时决定了才决定用那个函数。

也就是说用父类指针通过虚函数来决定运行时刻到底是谁而指向谁的函数。

//////////////////////////////////////////////////////////////////////用虚函数#include <iostream.h>class animal{public:animal();~animal();void fun1(animal *maybedog_maybehorse);virtual void born();};void animal::fun1(animal *maybedog_maybehorse){maybedog_maybehorse->born();}animal::animal(){}animal::~animal(){}void animal::born(){cout<< "animal";}class dog: public animal {public:dog();~dog();virtual void born();};dog::dog(){}dog::~dog(){}void dog::born(){cout<<"dog";}class horse:public animal {public:horse();~horse();virtual void born();};horse::horse(){}horse::~horse()}void horse::born(){cout<<"horse";}void main(){animal a;dog b;horse c;a.fun1(&c);}//output: horse///////////////////////////////////////////////////////////////// //不用虚函数#include <iostream.h>class animal{public:animal();~animal();void fun1(animal *maybedog_maybehorse);void born();};void animal::fun1(animal *maybedog_maybehorse){maybedog_maybehorse->born();}animal::animal(){}animal::~animal(){void animal::born(){cout<< "animal";}class dog: public animal {public:dog();~dog();void born();};dog::dog(){}dog::~dog(){}void dog::born(){cout<<"dog";}class horse:public animal {public:horse();~horse();void born();};horse::horse(){}horse::~horse(){}void horse::born(){cout<<"horse";}void main()animal a;dog b;horse c;a.fun1(&c);}output: animal---------------------------------------------------------------有纯虚函数的类是抽象类,不能生成对象,只能派生。

他派生的类的纯虚函数没有被改写,那么,它的派生类还是个抽象类。

相关文档
最新文档