实例讲解C++编程中的虚函数与虚基类

虚函数

#include "stdafx.h"

#include <iostream>

using namespace std;

class B0//基类B0声明

{

public:

void display(){cout<<"B0::display()"<<endl;}//公有成员函数

};

class B1: public B0//公有派生类B1声明

{

public:

void display(){cout<<"B1::display()"<<endl;}//公有成员函数

};

class D1: public B1//公有派生类D1声明

{

public:

void display(){cout<<"D1::display()"<<endl;}//公有成员函数

};

void fun(B0 *ptr)//普通函数

{//参数为指向基类对象的指针

ptr->display();//"对象指针->成员名"

}

void main()//主函数

{

B0 b0;//声明基类B0类对象

B1 b1;//声明B1类对象

D1 d1;//声明D1类对象

B0 *p;//声明B0类指针

p=&b0;//B0类指针指向B0类对象,

fun(p);

p=&b1;//B0类指针指向B1类对象,指向基类的指针也可以指向派生类。

fun(p);

p=&d1;//B0类指针指向D1类对象,指向基类的指针也可以指向派生类。

fun(p);

}

输出结果:

B0::display()

B0::display()

B0::display()

Press any key to continue

类型兼容规则举例

#include "stdafx.h"

#include <iostream>

using namespace std;

class B0//基类B0声明

{

public:

virtual void display(){cout<<"B0::display()"<<endl;}//公有成员函数

};

class B1: public B0//公有派生类B1声明

{

public:

void display(){cout<<"B1::display()"<<endl;}//公有成员函数

};

class D1: public B1//公有派生类D1声明

{

public:

void display(){cout<<"D1::display()"<<endl;}//公有成员函数

};

void fun(B0 *ptr)//普通函数

{//参数为指向基类对象的指针

ptr->display();//"对象指针->成员名"

}

void main()//主函数

{

B0 b0;//声明基类B0类对象

B1 b1;//声明B1类对象

D1 d1;//声明D1类对象

B0 *p;//声明B0类指针

p=&b0;//B0类指针指向B0类对象,

fun(p);

p=&b1;//B0类指针指向B1类对象,指向基类的指针也可以指向派生类。

fun(p);

p=&d1;//B0类指针指向D1类对象,指向基类的指针也可以指向派生类。

fun(p);

}

输出结果:

B0::display()

B1::display()

D1::display()

Press any key to continue

虚函数是为了实现某种功能而假设的函数,虚函数只能是类中的一个成员函数,不能是静态成员,使用关键字virtual用于在类中说明该函数是虚函数。 虚函数更是为了实现面向对象的多态性而产生的,使用虚函数和多态

性能够简化代码长度,支持更简单的顺序,便于程序的调试,维护。

虚函数的定义方法:

class A

{

public:

virtual void fun(); //define virtual function

};

void A::fun() { ... } //member function describe

上面定义了一个虚函数,然后在类体外进行了函数的具体描述。

在类的继承当中,当基类中声明了某个虚函数,即使在派生类中没有声明虚函数,那么在以后的继承结构中都是

虚函数,当然如果有多重继承,在每个派生类中还是推荐对每个虚函数进行显式的声明。

为了说明虚函数在派生类中的应用,我写段代码作例子:

#include "stdio"

class cbase

{

public:

virtual void vfoo()

{

printf("vfoo from cbase/n");

};

void foo()

{

printf("foo from cbase/n");

}

};

class cderivd : public cbase

{

public:

virtual void vfoo()

{

printf("vfoo from cderivd/n");

};

void foo()

{

printf("foo from cderivd/n");

};

};

int main(int argc, char* argv[])

{

cbase* pbase = new cderivd();

pbase->foo(); //非虚函数,根据指针类型决定调用哪个foo,本例指针类型为cbase,所以调用的是cbase::foo()

pbase->vfoo(); //虚函数,调用的是派生类的vfoo

delete pbase;

cderivd* pd = new cderivd();

pd->foo(); //非虚函数,本例指针类型为cderivd*,所以调用cderivd::foo();

pd->vfoo();

delete pd;

cderivd d;

d.foo();

d.vfoo();

((cbase)d).foo(); //将d强行切割为cbase,这时调用的无论是foo还是vfoo都将是base的

((cbase)d).vfoo();

getchar();

return 0;

}

程序在DevCPP下编译通过,输出:

foo from cbase

vfoo from cderivd

foo from cderivd

vfoo from cderivd

foo from cderivd

vfoo from cderivd

foo from cbase

vfoo from cbase

虚基类

#include "stdafx.h"

#include<iostream>

#include<string>

using namespace std;

class person{//声明基类

protected:

int age;

char sex;

string name;

public:

person(int a,char s,string nam){

age=a;

sex=s;

name=nam;

}

};

class teacher:virtual public person

{

protected:

string title;

public:

teacher(int a,char s,string nam,string t):person(a,s,nam){

title=t;

}

};

class student:virtual public person

{

protected:

float score;

public:

student(int a,char s,string nam,float sc):person(a,s,nam){

score=sc;

}

};

class graduate:public teacher,public student

{

protected:

float wdge;

public:

graduate(int a,char s,string nam,string t,float sc,float wd):person(a,s,nam),teacher(a,s,nam,t),student(a,s,nam,sc){

wdge=wd;

}

void show(){

cout<<name<<endl;

cout<<age<<endl;

cout<<sex<<endl;

cout<<title<<endl;

cout<<score<<endl;

cout<<wdge<<endl;

}

};

int main(){

graduate gr(22,'f',"k;asdjf;daf","klsdaf",89.5,79.5);

gr.show();

return 0;

}

输出结果:

k;asdjf;daf

22

f

klsdaf

89.5

79.5

Press any key to continue

以上是 实例讲解C++编程中的虚函数与虚基类 的全部内容, 来源链接: utcz.com/z/342900.html

回到顶部