C++学习21 基类和派生类的赋值

在C/C++中，经常会发生数据类型转换，例如整型数据可以赋值给浮点型变量，在赋值之前，先把整型数据转换为浮点型；反过来，浮点型数据也可以赋值给整型变量。

数据类型转换的前提是，编译器知道如何对数据进行取舍。例如：

int a = 10.9;
printf("%d
", a);

输出结果为 10，编译器会将小数部分直接丢掉（不是四舍五入）。再如：

float b = 10;
printf("%f
", b);

输出结果为 10.000000，编译器会自动添加小数部分。

类也是一种数据类型，也可以发生数据类型转换。不过这种转换只有在基类和派生类之间才有意义。

由于派生类包含从基类继承的成员，因此可以将派生类的对象赋值给基类对象，如下所示：

class A{
public:
    int m;
};
class B: public A{
public:
    int n;
};
A a;
B b;
a = b;
a.m = 2;

A是B的基类，a、b 分别是它们的对象，所以可以将 b 赋值给 a，然后通过 a 来访问成员变量 m。

实际上，对象之间的赋值是成员变量的赋值，成员函数不存在赋值问题。在赋值时，会舍弃派生类自己的成员，也就是”大材小用“，如下图所示：

可以发现，即使将派生类对象赋值给基类对象，基类对象也不会包含派生类的成员，所以依然不同通过基类对象来访问派生类的成员。对于上面的例子，a.m 是正确的，但 a.n 就是错误的，因为 a 不包含成员 n。

这种转换关系是不可逆的，只能用派生类对象给基类对象赋值，而不能用基类对象给派生类对象赋值。理由是很显然的，基类不包含派生类的成员，无法对派生类的成员变量赋值。同理，同一基类的不同派生类对象之间也不能赋值。

要理解这个问题，还得从赋值的本质入手。赋值实际上是向内存填充数据，当数据较多时很好处理，舍弃即可；上例中，a=b 时，成员 n 是多余的，会被直接丢掉，所以不会发生赋值错误。但当数据较少时，问题就很棘手，编译器不知道如何填充剩下的内存；上例中，b= a 时，编译器不知道该如何给变量 n 赋值，所以会发生错误。

请看下面一个完整的例子：

#include <iostream>
using namespace std;
class A{
public:
    int n;
    A(int n):n(n){}
    void display(){ cout<<"Class A: n="<<n<<endl;}
};
class B: public A{
public:
    B(int n):A(n){}
    void display(){ cout<<"Class B: n="<<n<<endl;}
};
class C: public A{
public:
    C(int n):A(n){}
    void display(){ cout<<"Class C: n="<<n<<endl;}
};
int main(){
    A a(1);
    B b(2);
    C c(3);
    a.display();
    a = b;
    b.n = 100;
    a.display();
    a = c;
    a.display();
    return 0;
}

本例中，将 b 对象赋值给 a 对象，等价于 a.n = b.n，赋值完成后 a.n 的值为 2，然后调用 a.display() 函数，输出结果就是”Class A: n=2“。将 c 对象赋值给 a 对象也是同样的道理。

这个例子很好的说明了：基类对象和派生类对象之间的赋值仅仅是对应的成员变量的赋值，不会影响成员函数，不会影响 this 指针。

总结：可以通过派生类对象访问派生类的成员，但无论如何，也不能通过基类对象访问派生类成员。

指向对象的指针

对上例 main 函数中的代码做如下更改：

A *p = new A(1);
p->display();
p = new B(2);
p->n = 100;
p->display();
p = new C(3);
p->display();

输出结果：
Class A: n=1
Class A: n=100
Class A: n=3

本例定义了一个指针，使它指向不同的对象。与上例不同的是，本例中并没有发生对象的赋值，仅仅是改变了指针的指向。

输出结果的第2行与上例不同，这是为什么呢？

在代码第3行中，将 p 指向 B 类的对象，隐式指针 this 也随之改变，指向 B 类的对象，所以 p->n 和 this->n 访问的都是 B 类对象的成员变量，输出结果显然是”n=100“。

细心读者可能已经发现，虽然 this 指向了 B 类对象，但是 p->display() 依然调用 A 类的成员函数。这是因为，成员变量和成员函数不在同一个内存区域，系统通过 this 指针来访问成员变量，但是却不通过它来访问成员函数。

系统通过对象的类型来访问成员函数。例如 p 的类型是 A，那么不管 p 指向哪个对象，都访问 A 类的成员函数。