C/C++日常学习总结（第五篇）多态和虚函数的访问

1.多态性

多态性是面向对象程序设计的精髓，简单的一句话：一个接口，多种方法。

多态性分为静态多态性和动态多态性，这个“静态”和“多态”是由编译器决定的，能够在编译阶段就能根据函数名和传递的参数确定调用哪个函数，这就叫静态联编；只能在运行时才能决定调用哪个函数，叫做动态联编。

 静态多态性:表现方式为函数重载和运算符重载

 动态多态性:表现方式为虚函数virtual

 

多态还有个关键之处就是一切用指向基类的指针或引用来操作对象.

2.虚函数

  例子：http://download.csdn.net/detail/wu_123_456/7695201

（1.）其定义很简单就是在函数名前面加上virtual，例如：

virtual void print()
{
}

（2.）如果基类中定义为虚函数，那么在它的所有派生类中也保持为虚函数，即使派生类中省略了virtual关键字，也为虚函数。

（3.）派生类中重定义虚函数，格式有一定的要求：

          1）.与基类中的虚函数有相同的参数个数

          2）.与基类中的虚函数有相同的参数类型

          3）.与基类中的虚函数有相同的返回类型

 

3.为什么构造函数不能为虚函数？

class A
{
 public:
       A()
       {
           cout<<"调用A的构造函数"<<endl;
       }
};
class B:public A
{
 public:
       B():A()
       {
           cout<<"调用B的构造函数"<<endl;
       }
};

int main()
{
   B  b;
   return 0;
}

【解析】：

（1.）根据继承关系，调用关系是先执行A的构造函数，再执行B的构造函数；

（2.）如果A的构造函数是虚函数，B也给出了构造函数，则只会执行B的构造函数，A就不能构造了

（3.）（1.）和（2.）相互矛盾

 

4.虚函数的访问

（1.）对象名访问，调用哪个函数取决于对象名的类型

class Base
{
public:
    virtual  void print()
    {
         cout<<"调用Base的print()"<<endl;
    }
};

class Child:public Base
{
public:
    virtual  void print()
    {
         cout<<"调用Child的print()"<<endl;
    }
};
int main()
{
   Base   base;               //创建基类的对象
   Child  child;              //创建派生类对象
   base.print();              //通过对象名调用虚函数
   child.print();
   child.Base::print();       //也可通过域名限定符指明要调用哪个函数
   child.Child::print();
   return 0;
}

 

（2.）指针访问

class Base
{
public:
    virtual  void print()
    {
         cout<<"调用Base的print()"<<endl;
    }
};

class Child:public Base
{
public:
    virtual  void print()
    {
         cout<<"调用Child的print()"<<endl;
    }
};
int main()
{
   Base    base;                   //创建基类的对象
   Base   *pbase = &base; 
   Child   child;                  //创建派生类对象
   Child  *pchild = &child;   
   

   pbase->print();                //基类调用虚函数
   pchild->print();               //派生类调用
   pchild = (Child*)&base;        //反向转换，基类对象地址给派生类指针赋值
   pchild->print();               //派生类调用基类的虚函数，只跟所指对象类型有关

   pbase =   pchild;
   pbase->print();                //基类指针调用
 

   pchild->Base::print();         //也可通过域名限定符指明要调用哪个函数
   return 0;
}

 

（3.）引用访问

class Base
{
public:
    virtual  void print()
    {
         cout<<"调用Base的print()"<<endl;
    }
};

class Child:public Base
{
public:
    virtual  void print()
    {
         cout<<"调用Child的print()"<<endl;
    }
};
int main()
{
  Base  base;
  Base &rbase = base;      //基类引用
  rbase.print();           //调用基类中的函数

  Child child;
  Child &rchild=child;     //派生类引用
  rchild.print();          //调用派生类中函数

  rchild=base;
  rchild.print();          //还是调用派生类中函数

  rbase = child;
  rbase.print();           //原理同上
  return 0;
}

 

【解析】：

1.）使用引用访问虚函数，跟用指针访问类似

2.）不同的是：引用一经声明之后，不管后面引用变量本身怎么改变，其调用的函数不会改变，始终指向开始定义时指向的函数。

 

（4.）类内访问（要使用this指针）

// 在类内的成员函数中访问该类层次中的虚函数，要使用this指针
#include <iostream>
using namespace std;

class base				//基类定义
{
public:
	virtual void disp()		//虚函数disp
	{
		cout<<"hello,base"<<endl;
	}

	void call_base_1()
	{
		this->disp();		//或直接用disp()
	}

	void call_base_2()
	{
		base::disp();		//去掉bass::再试试
	}
};

class child:public base		        //派生类定义
{
public:
	void disp()				//对虚函数进行了覆盖定义
	{
		cout<<"hello,child"<<endl;
	}

	void call_child_1()
	{
		disp();				//等价于this->disp();
	}

//	函数call_base_1()在child类中虽然没有直接写出来，
//	但还是继承过来了，默认和base类的代码是一样的
//	void call_base_1()
//	{
//		this->disp();
//	}

//	函数call_base_2()在child类中虽然没有直接写出来，
//	但还是继承过来了，默认和base类的代码是一样的
//	void call_base_2()
//	{
//		base::disp();
//	}
};

int main()
{
	base obj_Base;			//声明一个基类对象
	child obj_Child;		//声明一个派生类对象
	obj_Base.call_base_1();	        //基类对象调用非虚函数call_base_1()
	obj_Child.call_child_1();       //派生类对象调用非虚函数call_child_1()

	cout << endl;

	base* pBase = &obj_Base;        //声明一基类指针，并用基类对象地址为其初始化
	pBase->call_base_1();	        //使用基类指针在成员函数内调用虚函数
	pBase->call_base_2();

	cout << endl;

	pBase = &obj_Child;		//用派生类对象地址为基类指针初始化
	pBase->call_base_1();	        //使用基类指针在成员函数内调用虚函数
	pBase->call_base_2();

	return 0;
}

【参考链接】：http://hi.baidu.com/huifeng00/item/ef6479f70f7e38bc31c19991