深度探索c++对象模型-20-静东态、绑定、坑点、多态体现深谈

有如下代码：

class Base
{
public:

	 
};
class Derive :public Base
{
public:
	
};

class Derive2:public Base
{
public:

};

一、静态类型和动态类型
静态类型：对象定义时的类型，编译期间就确定好了。

void main()
{
	//静态类型：
	Base base;//base的静态类型是Base
	Derive derive;//derive的静态类型是Base
	Base *pbase;//pbase的静态类型是Base *
	Base *pbase2 = new Derive();//pbase2的静态类型是Base *
	Base *pbase3 = new Derive2();//pbase3的静态类型是Base *
	system("pause");
}

动态类型：对象目前所指向的类型（运行的时候才决定的类型），一般只有指针或者引用才有动态类型。而且一般都是父类的指针或者引用。

void main()
{

	Base base;//base的静态类型是Base；没有动态类型，因为不是指针不是引用
	Derive derive;//derive的静态类型是Base；没有动态类型，因为不是指针不是引用
	Base *pbase;//pbase的静态类型是Base * ；至少目前没有动态类型，因为它没有指向任何对象
	Base *pbase2 = new Derive();//pbase2的静态类型是Base *，动态类型是Derive
	Base *pbase3 = new Derive2();//pbase3的静态类型是Base *，动态类型是Derive2
	system("pause");
}

另外，动态类型在执行过程中可以改变，比如。

pbase = pbase2;//pbase的动态类型为Derive
pbase = pbase3;//pbase的动态类型为Derive2

二、静态绑定和动态绑定
静态绑定：绑定的是静态类型，所对应的函数或者属性依赖于对象的静态类型 ，发生在编译期间

动态绑定：绑定的是动态类型，所对应的函数或者属性依赖于对象的动态类型，发生在运行期间。

2.1 普通成员函数是静态绑定，而虚函数时动态绑定
2.2缺省参数一般是静态绑定

三、继承的非虚函数坑
看如下代码：

class Base
{
public:

	void myfunc()
	{
		cout << "Base::mufunc()\n";
	}
};
class Derive :public Base
{
public:
	void myfunc()
	{
		cout << "Derive::mufunc()\n";
	}
};

class Derive2:public Base
{
public:

};


void main()
{

	Derive derive;
	Derive *pderive = &derive;
	pderive->myfunc();//Derive::mufunc()
	 
	Base *pbase = &derive;
	//(普通成员函数是静态绑定，换句话说，myfunc()是普通成员函数。这里到底调用父类的myfunc, 还是子类的，取决于调用者的静态类型)
	pbase->myfunc();//Base::mufunc 
	//因为这里的pbase的静态类型是Base,所以调用的是Base的myfunc();
	system("pause");
}

结果：

结论：不应该在子类中重新定义一个继承来的非虚函数。
四、虚函数的动态绑定
看代码：

void main()
{

	Derive derive;
	Derive *pderive = &derive;
	pderive->myfunc();//Derive::mufunc()
	 
	Base *pbase = &derive;
	//(普通成员函数是静态绑定，换句话说，myfunc()是普通成员函数。这里到底调用父类的myfunc, 还是子类的，取决于调用者的静态类型)
	pbase->myfunc();//Base::mufunc 
	//因为这里的pbase的静态类型是Base,所以调用的是Base的myfunc();

	cout << "-----------------\n";
	pderive->myvirfunc();//执行Derive的myvirfunc,
	pbase->myvirfunc();//pbase动态类型是Derive,而虚函数是动态绑定，参照是它的动态类型->Derive::myvirfunc()

	Base base;
	pbase = &base;
	pbase->myvirfunc();//pbase动态类型是Base,而虚函数是动态绑定，参照是它的动态类型->Base::myvirfunc()
	system("pause");
}

结果：

虚函数是动态绑定；换句话说 myvirfunc()是虚函数，这里到底执行哪个myvirfunc()取决于调用者的动态类型。
五、重新定义虚函数的缺省参数坑

class Base
{
public:

	void myfunc()
	{
		cout << "Base::mufunc()\n";
	}

	virtual void myvirfunc(int nvalue = 1)
	{
		cout << "Base::myvirfunc(),nvalue:" << nvalue << endl;
	}
};
class Derive :public Base
{
public:
	void myfunc()
	{
		cout << "Derive::mufunc()\n";
	}

	virtual void myvirfunc(int nvalue = 2)
	{
		cout << "Derive::myvirfunc(),nvalue:" << nvalue << endl;
	}
};

class Derive2:public Base
{
public:

};


void main()
{

	Derive derive;
	Derive *pderive = &derive;
	pderive->myfunc();//Derive::mufunc()
	 
	Base *pbase = &derive;
	//(普通成员函数是静态绑定，换句话说，myfunc()是普通成员函数。这里到底调用父类的myfunc, 还是子类的，取决于调用者的静态类型)
	pbase->myfunc();//Base::mufunc 
	//因为这里的pbase的静态类型是Base,所以调用的是Base的myfunc();

	cout << "-----------------\n";
	pderive->myvirfunc();//执行Derive的myvirfunc,
	pbase->myvirfunc();//pbase动态类型是Derive,而虚函数是动态绑定，参照是它的动态类型->Derive::myvirfunc()

	Base base;
	pbase = &base;
	pbase->myvirfunc();//pbase动态类型是Base,而虚函数是动态绑定，参照是它的动态类型->Base::myvirfunc()
	system("pause");
}

结果：

调用的是子类的myvirfuc(int nvalue = 2),但参数却是父类的nvalue=1.
总结：缺省参数一般是静态绑定。不要重新定义父类虚函数的缺省参数值。

六、c++中的多态性的体现

class A
{
public:
	virtual void myvirfunc()
	{

	}
};
void main()
{

	A *pa = new A();
	pa->myvirfunc();//从代码实现上就是多态

	A a;
	a.myvirfunc();//这个就不是多态

	
	system("pause");
}