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

【摘要】

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

【正文】

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

【代码示例 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:
<span style="white-space:pre">	</span>void virtual f()
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>cout << "A" << endl;
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>void rf1(int num = 1)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>ma = num;
<span style="white-space:pre">		</span>cout<<ma<<endl;
<span style="white-space:pre">	</span>}
private:
<span style="white-space:pre">	</span>int ma;
};
class B : public A
{
public:
<span style="white-space:pre">	</span>void virtual f()
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>cout << "B" << endl;
<span style="white-space:pre">	</span>}
<span style="white-space:pre">	</span>void rf2(int num = 2)
<span style="white-space:pre">	</span>{
<span style="white-space:pre">		</span>mb = num;
<span style="white-space:pre">		</span>cout<<mb<<endl;
<span style="white-space:pre">	</span>}
private:
<span style="white-space:pre">	</span>int mb;
};
int main()
{
<span style="white-space:pre">	</span>A* pa = new A();
<span style="white-space:pre">	</span>pa->f();        //A 显然
<span style="white-space:pre">	</span>pa->rf1();<span style="white-space:pre">		</span>//1
<span style="white-space:pre">	</span>B* pb = (B*) pa;
<span style="white-space:pre">	</span>pb->f();        //A  转化pa为B类型并新建一个指针pb，将pa复制到pb；pa的指向始终没有变化，所以pb也指向pa的f()函数，不存在覆盖问题。
<span style="white-space:pre">	</span>pb->rf1();<span style="white-space:pre">		</span>//1
<span style="white-space:pre">	</span>// pa->rf2();<span style="white-space:pre">		</span>//报错<span style="white-space:pre">	</span>
<span style="white-space:pre">	</span>delete pa, pb;
<span style="white-space:pre">	</span>pa = new B();
<span style="white-space:pre">	</span>pa->f();        //B 显然
<span style="white-space:pre">	</span>pa->rf1();<span style="white-space:pre">		</span>//1
<span style="white-space:pre">	</span>// pa->rf2();<span style="white-space:pre">		</span>//报错
<span style="white-space:pre">	</span>pb = (B*) pa;
<span style="white-space:pre">	</span>pb->f();        //B 覆盖
<span style="white-space:pre">	</span>pa->rf1();<span style="white-space:pre">		</span>//1
<span style="white-space:pre">	</span>// pa->rf2();<span style="white-space:pre">		</span>//报错
<span style="white-space:pre">	</span>return 0;
}

解析：

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

【最后的话】

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