有如下代码：
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");
}
