覆盖

例题1:

#include <iostream>
using namespace std;

class A {
protected:
		int m_data;
public:
	A(int data = 0) {
		m_data = data;
	}
	
	int GetData() {
		return doGetData();
	}
	
	virtual int doGetData() {
		return m_data;
	}
};

class B : public A {
protected:
	int m_data;
public:
	B(int data = 1) {
		m_data = data;
	}
	
	int doGetData() {
		return m_data;
	}
};

class C : public B {
protected:
	int m_data;
public:
	C(int data = 2) {
		m_data = data; 
	}
};

int main() {
	C c(10);
	
	cout << c.GetData() << endl; // 1
	cout << c.A::GetData() << endl; // 1
 	cout << c.B::GetData() << endl;// 1
	cout << c.C::GetData() << endl; // 1

	cout << c.doGetData() << endl; // 1
	cout <<c.A::doGetData() << endl; // 0
	cout <<c.B::doGetData() << endl; // 1
	cout <<c.C::doGetData() << endl; //1

 	return 0;
}

　　

析构函数从最初始的基类开始构造, 各个类的同名变量没有形成覆盖, 都是单独的变量, 这是重要的 C++ 特性

对于 cout << c.GetData() << endl;

本来是要调用 c 的函数, 但 c 并未定义, 因此去 c 的基类 B 寻找. B 依然没有, 再去 A 寻找, 在A 找到. 然后调用 doGetData() 函数, 该函数是虚函数, 因此再次从 C 找, 然后 B, 在 B 找到, 返回 1

接下来的四个函数分析和上面相同

对于 cout << c.A::doGetData() << endl;

直接调用 A 的函数, 返回 0

例题2:

class A {
public:
	void virtual f() {
		cout << "A" << endl;
	}
};

class B {
public:
	void virtual f() {
		cout << "B" << endl;
	}
};

int main() {
	A* pa = new A();
	pa->f(); //A
	B* pb = (B*) pa;
	pb->f();//B

	return 0;
}

　　

B* pb = (B*) pa;

这样操作, 只能改变静态类型, 动态类型保持不变