C++ 类继承与对象赋值情况下成员变量的覆盖浅析

桃扇骨 2022-08-01 19:29 21阅读 0赞

【摘要】

类的继承以及对象的赋值会带来成员变量的相互传递。这里详细讨论了，类间继承带来的成员变量的传递采用覆盖原则，采用函数级的成员变量的取值；对象赋值带来的成员变量的传递采用，实函数采用数据类型的实函数，虚函数采用赋值源的虚函数，成员变量采用赋值源的成员变量，其实也是函数级的成员变量。

【正文】

在类继承中，成员变量存在覆盖的情况，成员函数则存在隐藏和覆盖以及重载的情况。在类继承中，公有继承会导致公有成员变量的覆盖，从而使得成员函数的调用出现各种结果。

【代码示例 01】

#include<iostream>
 using namespace std;
 class A
 {
 public:
 int m_a;
 A()
 {
 m_a = 1;
 }
 void print ()
 {
 printf("%d",m_a);
 }
 };
 class B : public A
 {
 public:
 int m_a;
 B()
 {
 m_a = 2;
 }
 };
 int main ()
 {
 B b;
 b.print();
 printf("%d\n",b.m_a);
 }

解析：

B 类中的 m\_a 把 A 类中的 m\_a 覆盖掉了。在构造 B 类时，先调用 A 类的构造函数。所以， A 类中的m\_a 是1，b.print()打印的是 A 类中的m\_a而B类中的m\_a 是2。如果 B 类中存在函数 print，那么输出将是 B 的 print 函数以及 B 的成员变量。  
输出：  
12  
【小结】

因为，调用了基类中的函数，所以，变量也是采用基类中的变量，而不是本类中的变量。

【代码示例 02】

#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; //2
 	cout << c.B::GetData() << endl; //3
 	cout << c.C::GetData() << endl; //4
 	cout << c.doGetData() << endl; //5
 	cout << c.A::doGetData() << endl;//6
 	cout << c.B::doGetData() << endl;//7
 	cout << c.C::doGetData() << endl;//8
 	system("PAUSE ");
 	return 0;
 }

解析：

@1. 本来是调用C类的GetData(),C中未定义，故调用B中的，但是B中也未定义，故调用A中的GetData()，因为A中的doGetData()是虚函数，所以调用B类的doGetData()，而B类的doGetData返回B::m\_data,故输出1.  
@2. 因为A中的doGetData()是虚函数，又因为C类中未重定义该接口，所以调用B中的doGetData()，返回值同上。  
@3. 必须返回1  
@4. 同@1  
@5. 调用父类B中的doGetData()，输出1  
@6. 直接调用A中的doGetData()，所以输出0  
@7. 直接调用B中的doGetData()，所以输出1  
@8. 同@5  
【小结】

这里的成员变量采用保护的访问控制类型，成员变量是不会被子类覆盖的。一般成员函数的调用顺序是，自己有就用自己的，自己没有，自底向上的向基类索取。虚函数的调用顺序是：自己有就用自己的，自己没有则自顶向下检索，到距离自己最近的派生类停止，其实也是向上索取的原则。

**在基类与派生类的对象或者对象指针互相转换、赋值时，会产生变量传递、一般成员函数传递和虚函数传递。这里只讨论因为对象或者对象指针的转换，造成成员变量的传递。**

【代码示例 03】

#include<iostream>
 using namespace std;
 class A
 {
 public:
 	A()
 	{
 		m_a = 1;
 		m_b = 2;
 	}
 	~A(){};
 	void fun()
 	{
 		printf("%d%d",m_a,m_b);
 	}
 private:
 	int m_a;
 	int m_b;
 };
 class B
 {
 public:
 	B()
 	{
 		m_c=3;
 	}
 	~B();
 	void fun()
 	{
 		printf("%d",m_c);
 	}
 private:
 	int m_c;
 };
 void main ()
 {
 A a;
 B *p = (B *)(&a);
 p->fun();
 }

解析：

首先可以肯定的是上面的代码是非常槽糕的，无论是可读性还是安全性都很差。写这种代码的人，按照Jarne Stroustrup（C++标志化制定者）的说法，应该“斩立决”。

但是不得不说这也是一道很好考察你对内存偏移的理解的题：B \*p = (B \*)(&a); 。

这是一个野蛮的转化，强制把 a 地址内容看成是一个B类对象，p 指向的是 a 类的内存空间。

B类只有一个元素m\_c 但是 A类的内存空间存放第一个元素的位置是 m\_a， p指向的是对象的内存首地址，比如：0x22ff58，但p->fun()调用B::fun()来打印m\_c时，编译器对m\_c的认识就是m\_c距离对象的偏移量是0，于是打印了对象A首地址的偏移量0x22ff58+0变量值，即就是m\_a的值1 。

【代码示例 04】

#include<iostream>
 using namespace std;
 class A
 {
 public:
 	void virtual f()
 	{
 		cout << "A" << endl;
 	}
 	void rf1(int num = 1)
 	{
 		ma = num;
 		cout<<ma<<endl;
 	}
 private:
 	int ma;
 };
 class B : public A
 {
 public:
 	void virtual f()
 	{
 		cout << "B" << endl;
 	}
 	void rf2(int num = 2)
 	{
 		mb = num;
 		cout<<mb<<endl;
 	}
 private:
 	int mb;
 };
 int main()
 {
 	A* pa = new A();
 	pa->f();        //A 显然
 	pa->rf1();		//1
 	B* pb = (B*) pa;
 	pb->f();        //A  转化pa为B类型并新建一个指针pb，将pa复制到pb；pa的指向始终没有变化，所以pb也指向pa的f()函数，不存在覆盖问题。
 	pb->rf1();		//1
 	// pa->rf2();		//报错	
 	delete pa, pb;
 	pa = new B();
 	pa->f();        //B 显然
 	pa->rf1();		//1
 	// pa->rf2();		//报错
 	pb = (B*) pa;
 	pb->f();        //B 覆盖
 	pa->rf1();		//1
 	// pa->rf2();		//报错
 	return 0;
 }

解析：

实函数采用对象的数据类型，虚函数采用赋值源的数据类型，成员变量采用赋值源的数据类型的成员变量。如果对象被销毁，那么将采用对象新的指向数据类型，即为新的虚函数以及成员变量。

**【最后的话】**

**指针的类型是实函数的类型，指针所指向对象的类型是虚函数的类型也是变量的值 ！！！**