对象的静态类型和动态类型

  • 对象的静态类型：对象在声明是采用的类型，在编译期确定；

  • 对象的动态类型：当前对象所指的类型，在运行期决定，对象的动态类型可以更改，但静态类型无法更改。

1
2
3
4
5
6
7
8
9
10
class B{ };
 
class C: public B{ };
 
class D: public B{ };
 
D* d = new D();	// d 的静态类型是它声明的类型 D*，动态类型也是 D*
B* b = d; 		// b 的静态类型是它声明的类型 B*，动态类型是 b 所指的对象 d 的类型 D*
C* c = new C();
b = c;			// b 的动态类型可以改变，现在它的动态类型为 C*

静态绑定和动态绑定

  • 静态绑定：绑定的是对象的静态类型，某特性（比如函数）依赖于对象的静态类型，发生在编译期。

  • 动态绑定：绑定的是对象的动态类型，某特性（比如函数）依赖于对象的动态类型，发生在运行期。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class B {
    void DoSomething();
    virtual void vfun();
};
 
class C: public B {
    // 重新定义了父类的 no-virtual 函数，会导致名称遮掩；很不好的设计
    void DoSomething();
    virtual void vfun();
};
 
class D: public B{
    void DoSomething();
    virtual void vfun();
};
 
D* d = new D();	// d 的静态类型是它声明的类型 D*，动态类型也是 D*
B* b = d;		// b 的静态类型是它声明的类型 B*，动态类型是 b 所指的对象 d 的类型 D*

问题一：d->DoSomething() 和 b->DoSomething() 调用的是同一个函数吗？
答案：不是的，虽然 d 和 b 指向同一对象，但函数 DoSomething() 是一个 non-virtual 函数，它是静态绑定的，也就是编译器会在编译器根据对象的静态类型来选择函数，d 的静态类型是 D*，那么编译器在处理 d->DoSomething() 的时候会将它指向 D::DoSomething()。同理，b 的静态类型是 B*，那么 b->DoSomething() 调用的就是 B::DoSomething()。

问题二：d->vfun()和 b->vfun() 调用的是同一函数吗？
答案：是的，vfun() 是个虚函数，它是动态绑定的，也就是它绑定的是对象的动态类型，b 和 d 虽然静态类型不同，但他们指向同一个对象，他们的动态对象是相同的，都是 D*，所以，他们调用的是同一个函数：D::vfun()。

上面都是针对对象指针的情况，对于引用（reference）的情况同样适用。

总结：只有虚函数才使用的是动态绑定，其他的全部是静态绑定。

缺省虚函数的动态绑定

当缺省参数和虚函数一起出现的时候情况有点复杂，极易出错。我们知道，虚函数是动态绑定的，但是为了执行效率，缺省参数是静态绑定的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class B {
    void DoSomething();
    virtual void vfun(int i = 10); // 默认 10
};

class D: public B {
    void DoSomething();
    virtual void vfun(int i = 20); // 继承但是默认 20
};
 
D* d = new D();	// d 的静态类型是它声明的类型 D*，动态类型也是 D*
B* b = d;		// b 的静态类型是它声明的类型 B*，动态类型是 b 所指的对象 d 的类型 D*
d->vfun();
b->vfun();

有上面的分析可知，d->vfun() 和 b ->vfun() 调用都是函数 D::vfun()，但是他们的缺省参数是多少？

分析一下，缺省参数是静态绑定的，d->vfun()，d 的静态类型是 D*，所以它的缺省参数是 20；而 b 的静态类型是 B*，所以 b->vfun() 的缺省参数是10.

对于这个特性，估计没有人会喜欢。所以，永远记住：

“绝不重新定义继承而来的缺省参数（Never redefine function’s inherited default parameters value.）”