类成员函数的重载、重写、和覆盖区别

1、类成员函数的重载、重写、和覆盖区别

    a.成员函数被重载的特征：

     （1）相同的范围（在同一个类中）；

     （2）函数名字相同；

     （3）参数不同；

     （4）virtual关键字可有可无。

    b.覆盖是指派生类函数覆盖基类函数，特征是：

     （1）不同的范围（分别位于派生类与基类）；

     （2）函数名字相同；

     （3）参数相同；

     （4）基类函数必须有virtual关键字。

    c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

     （1）如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏（注意别与重载混淆）。

     （2）如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual关键字。此时，基类的函数被隐藏（注意别与覆盖混淆）

2、"隐藏"实例分析

#include "stdafx.h"
#include <iostream.h>
#include <string.h>

class A
{
public:
	void hello(){cout<<"A hello"<<endl;}
	virtual void hello(int i){cout<<"A hello int"<<endl;}
};

class B:public A
{
public:
	void hello() const{cout<<"B hello"<<endl;} //B中的hello()隐藏了A中的hello(int)
};

//重载时的隐藏问题,解决办法，在B中重新定义hello(int)函数
void main()
{
	B b;
	b.hello();
//	b.hello(1);  //error
}

3、虚函数实例分析1

#include "stdafx.h"
#include <iostream.h>
#include <string.h>

class A
{
protected:
	int i;
public:
	A(int d=0){i=d;}
	int GetData(){return doGetData();}
	virtual int doGetData(){return i;}       //虚函数
};

class B:public A
{
protected:
	int i;
public:
	B(int d=1){i=d;}
	int doGetData(){return i;}      
};

class C:public B
{
protected:
	int i;
public:
	C(int d=2){i=d;}
};

void main()
{
	C c(10);

	/* B和的C对象调用一般成员函数GetData()都是调用的A类中的GetData()，因为A中的doGetData()是虚函数，所以调用B类中的doGetData() */
	/* B和的C对象调用虚函数doGetData()都是调用的B类中的重定义的doGetData()，除非显示指定调用哪个类的虚函数  */

	cout<<c.GetData()<<" ";        /*  本来要调用C的GetData(),C中未定义，故调用B中的，但是B中也未定义，故调用A的GetData(),因为A中的doGetData()是虚函数，所以调用B中的doGetData()，返回B::i */
	cout<<c.A::GetData()<<" ";     	
	cout<<c.B::GetData()<<" ";
	cout<<c.C::GetData()<<" ";

	cout<<c.doGetData()<<" ";      /*  调用B类中的doGetData() */
	cout<<c.A::doGetData()<<" ";   /*  直接调用A类中的doGetData() */
	cout<<c.B::doGetData()<<" ";   /*  直接调用B类中的doGetData() */
	cout<<c.C::doGetData()<<endl;  /*  因为C没有重定义doGetData(),所有调用B中的doGetData()*/

	//答案：1 1 1 1 1 0 1 1
}

4、虚函数实例分析2

#include "stdafx.h"
#include <iostream.h>
#include <string.h>

class A
{
public:
	virtual void display(){cout<<"A"<<endl;}       //虚函数
};

class B:public A
{
public:
	virtual void display(){cout<<"B"<<endl;}       //虚函数   
};

void main()
{
	A *pa=new A;
    pa->display();     //调用A中的虚函数
	B *pb=(B*)pa;      //pb指向pa，而pa始终指向A的对象，故调用A中的虚函数
	pb->display();

	delete pa,pb;

	pa=new B;
	pa->display();     //调用B中的虚函数
	pb=(B*)pa;         //pb指向pa，pa始终指向B的对象，故调用B中的虚函数
	pb->display();
}

5、虚继承分析

#include "stdafx.h"
#include <iostream.h>
#include <string.h>

class A
{
	char a[3];
public:
	virtual void display1(){}       //虚函数
};

class B:public virtual A  //虚继承
{
	char b[3];
public:
	virtual void display2(){}       //虚函数   
};

class C:public virtual B  //虚继承
{
	char c[3];
public:
	virtual void display3(){}       //虚函数   
};

void main()
{
	cout<<sizeof(A)<<" ";  //8    char a[3]、虚指针
	cout<<sizeof(B)<<" ";  //20   char b[3]、虚指针、虚继承的指针、父类
	cout<<sizeof(C)<<endl; //32   char c[3]、虚指针、虚继承的指针、父类
}