关于虚函数的应用（10个例子）

Author： bakari Date: 2012.4.8

装载引用请注明出处：/article/5171914.html 谢谢！

虚函数是C++中非常重要的一个概念，它最大的好处是能够触发动态绑定。C++中的函数默认不使用动态绑定，要触发动态绑定，必须满足 两个条件：

第一，只有指定为虚函数的成员函数才能进行动态绑定，成员函数默认为非虚函数，非虚函数不进行动态绑定；

第二，必须通过基类类型的指针或引用进行函数的调用。具体理解指针或引用在使用继承层次中某一类型的对象时会发生什么，本文不展开讨论，

这两天主要研习了虚函数的具体应用这一块，而它的应用又非常广泛，学MFC的应该能够感受到它的强大，要说是总结也不一定能够总结全，本人目前也处在studying中，所以用10个具体的例子来说明。例子是从难 到易，看到的朋友如果懂前面的可以不用看后面的。每一个例子就是一个类，通过类在内存中的布局来形象地分析虚函数究竟是如何运作的。图表示可能抽象一点，一般带有V开头的表示一个虚函数表，如果是学过编译原理这门课就很容易看懂，没学过的只要懂虚函数的一些机制，耐着性子也是没问题的。每个图示都配有相应的代码。可以对照着代码来看。

1、 虚函数继承的复杂例子

2、 菱形继承无虚拟继承的情况

3、 虚拟继承的简单情况

4、 单一普通继承（无虚函数）

5、 单一继承（含虚函数）（虚函数表只有一个）

6、 多重继承（不含虚函数）

7、 多重继承（一个含虚函数，一个不含虚函数）

8、 多重继承（两个都含有虚函数）

9、 纯虚汗继承

10、 private 的虚函数

1、虚函数继承的复杂例子，见下图：

见图：左边是这个类的内存布局，右边是继承图示。 farther类和Uncle类都是虚拟继承，其内部也都有偏移表，但我觉得这两个表只是内部隐藏的，不在Son的内存布局中表示出来，本题Son的内存只有32个字节，如果表示出来就不止32个了，但是下面这个地方在内存中显示是00 00 00 00，我猜想是不是GrandFather的偏移地址。

VbtSon(Father)

Farther~Num

VbtSon(Uncle)

Uncle~Num

Son~Num

Offset(这个地方？？)

Vftable(GrandFather)

GrandFather~Num

例子代码：

class GrandFather
{
public:
GrandFather():i_G(5){cout<<"GrandFather() is called!"<<endl;}
virtual ~GrandFather(){cout<<"~GrandFather() is called!"<<endl;}
public:
virtual void Test(){cout<<"GrandFather::Test() is called!"<<endl;}
private:
int i_G;
};

class Father: virtual public GrandFather             //虚拟继承
{
public:
Father():i_F(7){cout<<"Father() is called!"<<endl;};
virtual ~Father(){cout<<"~Father() is called!"<<endl;}
public:
virtual void Test(){cout<<"Father::Test() is called!"<<endl;}
private:
int i_F;
};

class Uncle: virtual public GrandFather                          //虚拟继承
{
public:
Uncle():i_U(3){cout<<"Uncle is called!"<<endl;}
virtual ~Uncle(){cout<<"~Uncle  is called!"<<endl;}
public:
virtual void Test(){cout<<"Uncle ::Test() is called!"<<endl;}
private:
int i_U;
};

class Son:public Father,public Uncle
{
public:
Son():i_S(9){cout<<"Son is called!"<<endl;};
virtual ~Son(){cout<<"~Son  is called!"<<endl;}
public:
virtual void Test(){cout<<"Son ::Test() is called!"<<endl;}
private:
int i_S;
};

int main(void)
{
Son p;
p.Test();
cout<<sizeof(Son)<<endl;
cout<<sizeof(Father)<<endl;
cout<<sizeof(GrandFather)<<endl;
return 0;
}

运行情况：



2、 菱形继承无虚拟继承的情况

VPTr1(Father)

GrandFarther~Num

Father~Num

VPtr(Uncle)

GrandFarther~Num

Uncle~Num

Son~Num

#include<iostream>
using namespace std;
class GrandFather
{
public:
GrandFather():i_G(5){cout<<"GrandFather() is called!"<<endl;}
virtual ~GrandFather(){cout<<"~GrandFather() is called!"<<endl;}
public:
virtual void Test(){cout<<"GrandFather::Test() is called!"<<endl;}
private:
int i_G;
};
class Father:   public GrandFather          //无虚拟继承
{
public:
Father():i_F(7){cout<<"Father() is called!"<<endl;};
virtual ~Father(){cout<<"~Father() is called!"<<endl;}
public:
virtual void Test(){cout<<"Father::Test() is called!"<<endl;}
private:
int i_F;
};

class Uncle:   public GrandFather             //无虚拟继承
{
public:
Uncle():i_U(3){cout<<"Uncle is called!"<<endl;}
virtual ~Uncle(){cout<<"~Uncle  is called!"<<endl;}
public:
virtual void Test(){cout<<"Uncle ::Test() is called!"<<endl;}
private:
int i_U;
};

class Son:public Father,public Uncle
{
public:
Son():i_S(9){cout<<"Son is called!"<<endl;};
virtual ~Son(){cout<<"~Son  is called!"<<endl;}
public:
virtual void Test(){cout<<"Son ::Test() is called!"<<endl;}
private:
int i_S;
};

int main(void)
{
Son p;
p.Test();
cout<<sizeof(Son)<<endl;
cout<<sizeof(Father)<<endl;
cout<<sizeof(GrandFather)<<endl;

return 0;
}

运行情况：



[b]3、 虚拟继承的简单情况 见下图：[/b]

VPTrD(A) 4

Offset(A) 4

A~number 4

D~number 4

VPtr(Base) 4

Base~Number 12 + 3cc + 4 = 40

class Base
{
public:
Base(){strcpy_s(ch_rc,"abcdefg");}                  //初始化Base()::im
public:
virtual void Read(){cout<<"Base::Read()is called!"<<endl;}
private:
char ch_rc[12];
bool ir;
int  im;
};
class A: virtual public Base     //虚拟继承
{
public:
A():im_A(5){}                        //初始化Ａ()::im_A
public:
virtual void Read(){cout<<"A::Read()is called!"<<endl;}
private:
int im_A;
};
class D:public A
{
public:
D():im_D(3){}
public:
virtual void Read(){cout<<"D::Read()is called!"<<endl;}
private:
int im_D;
};
int _tmain(int argc, _TCHAR* argv[])
{
D obj;
cout<<sizeof(D)<<endl;
return 0;
}

运行情况：



4、单一普通继承（无虚函数）（这个没什么好说的）

内存布局

Father~Number

Son~Number

class Father
{
public:
Father(){cout<<"Father() is called!"<<endl;}
void TestF(const int &m){
i_B=m;
cout<<"Father::TestF() is called!"<<endl;
}
void Test(){cout<<"Base::Test() is called!"<<endl;}
~Father(){cout<<"~Father() is called!"<<endl;}
private:
int i_B;
};

class Son:public Father
{
public:
Son():i_A(5){cout<<"Son() is called!"<<endl;}
void Test(){cout<<"Son::Test() is called!"<<endl;}
~Son(){cout<<"~Son() is called!"<<endl;}
private:
int i_A;
};
int main(int argc,char *argv[])
{
Father *p=new Son;
//Father *p=NULL;
p->Test();
delete p;
p=NULL;
cout<<sizeof(Son)<<endl;
return 0;
}

5、单一继承（含虚函数）（虚函数表只有一个）见图：

VPTr（father）

Father~number

Son~number

Child~number

#include<iostream>
using namespace std;
class Father
{
public:
Father(){cout<<"Father() is called!"<<endl;}
virtual  void Test(){cout<<"Base::Test() is called!"<<endl;}
virtual ~Father(){cout<<"~Father() is called!"<<endl;}
private:
int i_B;
};

class Son:public Father
{
public:
Son():i_A(5){cout<<"Son() is called!"<<endl;}
void Test(){cout<<"Son::Test() is called!"<<endl;}
~Son(){cout<<"~Son() is called!"<<endl;}
private:
int i_A;
};
int main(int argc,char *argv[])
{
Father *p=new Son;
//Father *p=NULL;
p->Test();
delete p;
p=NULL;
cout<<sizeof(Son)<<endl;
return 0;
}

运行情况：



6、多重继承（不含虚函数）（这个也没什么好说的）

直接看代码：

#include<iostream>
using namespace std;
class Father
{
public:
Father():i_B(6){cout<<"Father() is called!"<<endl;}
void TestF(const int &m){
i_B=m;
cout<<"Father::TestF() is called!"<<endl;
}
void Test(){cout<<"Father::Test() is called!"<<endl;}
~Father(){cout<<"~Father() is called!"<<endl;}
private:
int i_B;
};
class Son
{
public:
Son():i_A(5){cout<<"Son() is called!"<<endl;}
void Test(){cout<<"Son::Test() is called!"<<endl;}
~Son(){cout<<"~Son() is called!"<<endl;}
private:
int i_A;
};

class Child:public  Father,public Son      //多重继承
{
public:
Child():i_C(5){cout<<"Child() is called!"<<endl;}
void Test(){cout<<"Child::Test() is called!"<<endl;}
~Child(){cout<<"~Child() is called!"<<endl;}
private:
int i_C;
};
int main(int argc,char *argv[])
{
Father *p=new Child;
//Father *p=NULL;
p->Test();
cout<<sizeof(Son)<<endl;
cout<<sizeof(Child)<<endl;
return 0;
}

7、多重继承（一个含虚函数，一个不含虚函数）（类似单一继承）

VPTr（father）

Father~number

Son~number

Child~number

#include<iostream>
using namespace std;

class Father
{
public:
Father():i_B(6){cout<<"Father() is called!"<<endl;}
virtual  void TestF(const int &m){
i_B=m;
cout<<"Father::TestF() is called!"<<endl;
}
virtual void Test(){cout<<"Father::Test() is called!"<<endl;}
virtual  ~Father(){cout<<"~Father() is called!"<<endl;}
private:
int i_B;
};

class Son
{
public:
Son():i_A(5){cout<<"Son() is called!"<<endl;}
void Test(){cout<<"Son::Test() is called!"<<endl;}
~Son(){cout<<"~Son() is called!"<<endl;}
private:
int i_A;
};

class Child:public  Father,public Son
{
public:
Child():i_C(5){cout<<"Child() is called!"<<endl;}
void Test(){cout<<"Child::Test() is called!"<<endl;}
~Child(){cout<<"~Child() is called!"<<endl;}
private:
int i_C;
};
int main(int argc,char *argv[])
{
Father *p=new Child;
//Father *p=NULL;
p->Test();
cout<<sizeof(Son)<<endl;
cout<<sizeof(Child)<<endl;
return 0;
}

运行情况：



8、多重继承（两个都含有虚函数）

VPTr（father）

Father~number

VPTr(Son)

Son~number Child~number [b]20个字节[/b]

#include<iostream>
using namespace std;

class Father
{
public:
Father():i_B(6){cout<<"Father() is called!"<<endl;}
virtual  void TestF(const int &m){
i_B=m;
cout<<"Father::TestF() is called!"<<endl;
}
virtual void Test(){cout<<"Father::Test() is called!"<<endl;}
virtual  ~Father(){cout<<"~Father() is called!"<<endl;}
private:
int i_B;
};
class Son
{
public:
Son():i_A(5){cout<<"Son() is called!"<<endl;}
virtual void Test(){cout<<"Son::Test() is called!"<<endl;}
virtual ~Son(){cout<<"~Son() is called!"<<endl;}
private:
int i_A;
};

class Child:public  Father,public Son
{
public:
Child():i_C(7){cout<<"Child() is called!"<<endl;}
void Test(){cout<<"Child::Test() is called!"<<endl;}
~Child(){cout<<"~Child() is called!"<<endl;}
private:
int i_C;
};
int main(int argc,char *argv[])
{
//Father *p=new Child;
Child p;
//Father *p=NULL;
p.Test();
cout<<sizeof(Son)<<endl;
cout<<sizeof(Child)<<endl;
return 0;
}

运行情况：



9、纯虚汗继承

（只在父类中申明，并在子类中实现申明的函数才可以用）

内存分配与前面只含虚函数的情况类似

#include<iostream>
using namespace std;
class A
{
public:
A():i_A(5){cout<<"A() is called!"<<endl;}
public:
virtual void Test()= 0; //prue virtual function
virtual void Base() {cout<<"this is farther class"<<endl;}
private:
int i_A;
};

class B:public A
{
public:
B():i_B(9){}
public:
void Test() { cout<<" this is SubVirtual!"<<endl;}                          //必须在子类中实现该函数才可以用
void Base() {
cout<<"this is subclass Base"<<endl;
}
private:
int i_B;
};

int  main(void)
{
A* p = new B; //multstate pointer
p->Test();
p->Base();
cout<<sizeof(B)<<endl;
return 0 ;
}

10、private 的虚函数

#include<iostream>
using namespace std;

class A
{
public:
virtual void Test() { func();}
private:
int i_A;
virtual void func() {cout<<"A::func () is Called!"<<endl; }
};
class B: public A
{
private:
//虽然func()在A类中是private的，但是仍然可以出现在派生类中，并仍然可以与public或者protected的虚函数一样产生多态的效果。
virtual void func() { cout<<"B::func() is Called!"<<endl;} private:
int i_B;
};

int main(void)
{
//A *p=new B;
A p;
//B p;
//p->func();
p.Test();
cout<<sizeof(B)<<endl;
return 0;
}

运行情况：



OK，做这个东西很辛苦，没办法，搞技术的就得这样。

写这些程序然后进行测试是很轻松的一件事，然而要把这些东西以文字的方式整理出来，的确不是一件容易的事。所以，就有很多IT高手，技术流，Coding很厉害，但对于文字的东西就不是很感冒，不过没关系，每个人有每个人的不同的需求，我是喜欢没事总喜欢写写的人，我想写的越多思路就不会堵塞

祝愿每一个朋友学习愉快，技术成精！

每一个人的辛苦都是值得肯定的，装载引用请注明出处：/article/5171914.html 谢谢！