在C++中的一种函数申明被称之为:纯虚函数(pure virtual function).它的申明格式如下:
class CShape{public:virtual void Show()=0;};类的一个成员定位虚函数的实际意义在于让C++知道该函数并无意义,它的作用只是为了让派生类进行函数重载保留位置。注意红色部分,在普通的虚函数后面加上"=0"这样就声明了一个pure virtual function.废话不说先看例子:
1 #include <iostream>
2 #include <cstdlib>
3 #include <cstdio>
4
5 using namespace std;
6
7
8 class abstractcls
9 {
10 public:
11 abstractcls(float speed,int total) //构造函数
12 {
13 this->speed = speed;
14 this->total = total;
15 }
16
17 virtual void showmember()= 0; //纯虚函数的定义
18 protected:
19 float speed;
20 int total;
21 };
22
23 class car : public abstractcls
24 {
25 public:
26 car(int aird,float speed,int total):abstractcls(speed,total)
27 {
28 this->aird = aird;
29 }
30
31 virtual void showmember()
32 {
33 cout << speed <<"--------" <<total <<"-----------"<<aird<<endl;
34 }
35 protected:
36 int aird;
37 };
38 int main()
39 {
40 car b(250,150,4);
41 b.showmember();
42 return 0;
43 }
运行结果想必大家都知道!!就不写了!!
总结:什么时候需要用纯虚函数
1,当想要在基类中抽象出一个方法,且该类被继承类而不能被实例化时。
2,基类的方法必须在派生类中被实现时。
3,多个对象具有公共的抽象属性,但却有不同的实现要求时。
下面我们看一道某公司的面试的笔试题(含金量到底有多少??)
#include <iostream>
#include <cstdio>
using namespace std;
class A
{
public:
void foo()
{
printf("1n");
}
virtual void fuu()
{
printf("2n");
}
};
class B:public A
{
public :
void foo()
{
printf("3n");
}
void fuu()
{
printf("4n");
}
};
int main()
{
A a;
B b;
A *p = &a;
cout<< "p->foo()---" ; p->foo() ;
cout<<"p->fuu()---";p->fuu();
cout <<"-------向上转型-----------"<<endl;
p=&b;
cout<<"p->foo()---";p->foo();
cout<<"p->fuu()---";p->fuu();
cout <<"--------向下转型----------"<<endl;
B *ptr =(B *)&a;
cout<<"ptr->foo()----";ptr->foo();
cout<<"ptr->fuu()-----";ptr->fuu();
return 0;
}
先不要看答案,看自己能否作对??
运行结果:
下面进行详细分析一下为什么结果是这样的??你全做对了没??
第一个p->foo()和p->fuu()都很好理解,本身是基类指针,指向的又是基类对象,调用的都是基类本身的函数,因此输出结果就是1、2。
第二个输出结果就是1、4。p->foo()和p->fuu()则是基类指针指向子类对象,正式体现多态的用法,p->foo()由于指针是个基类指针,指向是一个固定偏移量的函数,因此此时指向的就只能是基类的foo()函数的代码了,因此输出的结果还是1。而p->fuu()指针是基类指针,指向的fuu是一个虚函数,由于每个虚函数都有一个虚函数列表,此时p调用fuu()并不是直接调用函数,而是通过虚函数列表找到相应的函数的地址,因此根据指向的对象不同,函数地址也将不同,这里将找到对应的子类的fuu()函数的地址,因此输出的结果也会是子类的结果4.
第三个并不是很理解这种用法,从原理上来解释,由于B是子类指针,虽然被赋予了基类对象地址,但是ptr->foo()在调用的时候,由于地址偏移量固定,偏移量是子类对象的偏移量,于是即使在指向了一个基类对象的情况下,还是调用到了子类的函数,虽然可能从始到终都没有子类对象的实例化出现。
第四个:而ptr->fuu()的调用,可能还是因为C++多态性的原因,由于指向的是一个基类对象,通过虚函数列表的引用,找到了基类中foo()函数的地址,因此调用了基类的函数。由此可见多态性的强大,可以适应各种变化,不论指针是基类的还是子类的,都能找到正确的实现方法。
小结:1.有virtual才可能发生多态现象2.不发生多态(无virtual)调用就按原类型调用
#include <iostream>
using namespace std;
class Base
{
public:
virtual void f(float x)
{
cout <<"Base::f(float)"<<x <<endl;
}
void g(float x)
{
cout <<"Base::g(float)"<<x<<endl;
}
void h(float x)
{
cout <<"Base::h(float)"<<x<<endl;
}
};
class Derived:public Base
{
public:
virtual void f(float x)
{
cout <<"Derived::f(float)"<<x<<endl;
}
void g(int x)
{
cout <<"Derived::g(int)"<<x <<endl;
}
void h(float x)
{
cout << "Derived::h(float)"<<x <<endl;
}
};
int main()
{
Derived d;
Base *pb = &d;
Derived *pd = &d;
pb->f(3.14f);
pd->f(3.14f);
pb->g(3.14f);
pd->g(3.14f);
pb->h(3.14f);
pd->h(3.14f);
system("pause");
}
运行结果:
虚函数和纯虚函数
在面向对象的C++语言中,虚函数(virtual function)是一个非常重要的概念。因为它充分体现了面向对象思想中的继承和多态性这两大特性,在C++语言里应用极广。比如在微软的MFC类库中,你会发现很多函数都有virtual关键字,也就是说,它们都是虚函数。难怪有人甚至称虚函数是C++语言的精髓。
那么,什么是虚函数呢,我们先来看看微软的解释:
虚函数是指一个类中你希望重载的成员函数,当你用一个基类指针或引用指向一个继承类对象的时候,你调用一个虚函数,实际调用的是继承类的版本。
——摘自MSDN
这个定义说得不是很明白。MSDN中还给出了一个例子,但是它的例子也并不能很好的说明问题。我们自己编写这样一个例子:
#include <iostream>
#include <conio.h>
using namespace std;
class Parent
{
public:
char data[20];
void Function1();
virtual void Function2();
}parent;
void Parent::Function1()
{
printf("This is parent,function1n");
}
void Parent::Function2()
{
printf("This is parent,function2n");
}
class Child:public Parent
{
void Function1();
void Function2();
}child;
void Child::Function1()
{
printf("This is child,function1n");
}
void Child::Function2()
{
printf("This is child,function2n");
}
int main()
{
Parent *p;
if(_getch()=='c')
p =&child;
else
p=&parent;
p->Function1();
p->Function2();
return 0 ;
}
输入非c字符:运行结果:
输入c字符:运行结果:
在这里就不过多解释以上程序,紧接着讲一下C++中虚函数和纯虚函数的虚别
首先:强调一个概念
定义一个函数为虚函数,不代表函数为不被实现的函数
定义他为虚函数是为了允许用基类的指针来调用子类的这个函数
定义一个函数为纯虚函数,才代表函数没有被实现
定义他是为了实现一个接口,起到一个规范的作用,规范继承这个
类的程序员必须实现这个函数。
对继承的影响:
普通的类(没有虚函数,纯虚函数)就可以被继承,而且工作的相当好
关于这个问题有以下疑问:
纯虚函数难道就是为了实现接口?接口存在的意义?
我实在弄不懂,我干嘛要预先定义好?未来的事情本难料
就等有一天我的类中需要使用某个函数,在添加一个函数
原文链接: https://www.cnblogs.com/haoyuanyuan/archive/2013/01/23/2872866.html
欢迎关注
微信关注下方公众号,第一时间获取干货硬货;公众号内回复【pdf】免费获取数百本计算机经典书籍
原创文章受到原创版权保护。转载请注明出处:https://www.ccppcoding.com/archives/76446
非原创文章文中已经注明原地址,如有侵权,联系删除
关注公众号【高性能架构探索】,第一时间获取最新文章
转载文章受原作者版权保护。转载请注明原作者出处!