【摘要】
类的继承以及对象的赋值会带来成员变量的相互传递。这里详细讨论了，类间继承带来的成员变量的传递采用覆盖原则，采用函数级的成员变量的取值；对象赋值带来的成员变量的传递采用，实函数采用数据类型的实函数，虚函数采用赋值源的虚函数，成员变量采用赋值源的成员变量，其实也是函数级的成员变量。
【正文】
【代码示例 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;
}
};
class B : public A
{
public:
void virtual f()
{
cout << "B" << endl;
}
};
int main()
{
A* pa = new A();
pa->f(); //A 显然
B* pb = (B*) pa;
pb->f(); //A 转化pa为B类型并新建一个指针pb，将pa复制到pb；pa的指向始终没有变化，所以pb也指向pa的f()函数，不存在覆盖问题。
delete pa, pb;
pa = new B();
pa->f(); //B 显然
pb = (B*) pa;
pb->f(); //B 覆盖
return 0;
}
解析：
实函数采用对象的数据类型，虚函数采用赋值源的数据类型，成员变量采用赋值源的数据类型的成员变量。如果对象被销毁，那么将采用对象新的指向数据类型，即为新的虚函数以及成员变量。
版权声明：本文为博主原创文章，未经博主允许不得转载。
原文地址：http://blog.csdn.net/u013630349/article/details/46722893
