C++ 中的动态绑定

C++中基类和派生类遵循类型兼容原则:即可用派生类的对象去初始化基类的对象，可用派生类的对象去初始化基类的引用可用派生类对象的地址去初始化基类对象指针。

C++中动态绑定条件发生需要满足2个条件:

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

2:必须通过基类类型的引用或指针进行函数调用

基类类型引用和指针的关键点在于静态类型和动态类型可能不同:

1:什么是静态类型?就我的理解来说，所谓的静态类型是指，当我们用上述引用或指针去调用非虚函数是，这是的引用和指针就是引种静态类型的，它对非虚函数的调用是在编译时就确定了

2:从静态类型的对立来看，所谓的动态类型也很明显，当这个引用或指针调用了虚函数时，它就是动态类型，它的行为要到程序运行时才能定义

那么用自己的理解来解释就是：当我们用派生类去初始化基类的引用或指针后，加入调用的是非虚函数，那么这时实际调用的函数是基类的函数；加入调用的是虚函数，那么这是调用的是派生类自己定义的虚函数。

下面是具体的例子来说明静态类型和动态类型

class A{

    public:

       virtual void show(){cout<<"j基类的show()"<<endl;}

       void get(){cout<<"基类的get()"<<endl;}

};

class B:public A{

       public:

      virtual void show(){cout<<“派生类的show()”<<endl;}

      void get(){cout<<"派生类的get()"<<endl;}

};

main：

   A a;

   B b;

   A &c=b;

   c.show();//show函数是虚函数，并且此时使用派生类的对象去初始化基类的引用，发生了动态绑定，调用的是实际类　　　　　　　　型B的show()----"派生类的show"

   c.get();//此时不满足动态绑定的条件，c是静态类型，结果是-------基类的get()

【转】动态绑定是面向对象的多态性的一种重要实现方式，常见的支持面向对象的语言（如C++，JAVA等）均支持动态绑定。但我使用C++的时候却发现其中动态绑定的实现和我想象中的有点不太一样，似乎类与类指针在动态绑定上有很大的差别。观察以下代码：

 

class SuperClass{
public:
 virtual void commonMethod(){ cout<<"SuperClass"<<endl;}
};

class SubA: public SuperClass{
public:
void commonMethod(){cout<<"SubA"<<endl;}
};

 

SubA getTarget(){
 SubA a;
 return a;
}

 

int main(){
 SuperClass s = getTarget();
 s.commonMethod();

 SubA sub = getTarget();
 sub.commonMethod();
}

 

最后打印的结果并不像我想象中那样都是子类的方法，而是为：

SuperClass

SubA

 

有了上面的结果，下面的修改就变得非常有意思了。我接着添加了新函数，用来返回类指针：

SuperClass* getTargetP(){
 return new SubA();
}

然后在main函数中有添加了如下测试语句：

 SuperClass* p_s =getTargetP();
 p_s->commonMethod();

 这次屏幕上打印出了SubA。

 

我感觉是这样的：

（我没有具体去查C++手册，因此下面的言论只是个人主观臆断）

如果用动态绑定的思路来理解上面的程序，那么第一行打印的也应该是SubA。不过C++没有这么实现，而是使用SuperClass将返回的对象s强制限定为SuperClass类型。结果就如我们看到的，打印的是父类中的方法，而非子类的方法，尽管父类的方法声明为virtual的。

 

这说明 C++在编译时就已经决定了用类来定义的对象，而类指针却是在运行时通过new方法获取对象的。在形如

SuperClass s;

来定义一个对象时，就已经调用了SuperClass的构造器（或默认构造器）。如果是

SubA a;

来定义一个对象时，不但调用了子类的构造器，还接着调用了父类的构造器这样在内存中也就出现了父类的对象，只不过你无法直接调用这个对象而已。现在通过上面看到的实验结果，我们可以很容易发现，

 SuperClass s = getTarget();
的定义s的方式其实是把这个存在于内存中隐含的父类对象又给挖出来了。当然了，这种挖掘方式多少带着点强制类型转换的意味。而类指针就不是这样，

 SuperClass* p_s =getTargetP();

就非常自然地用p_s指针接受了实际的SubA对象，从而在

 p_s->commonMethod();

语句中打印出了真实的子类对象方法。