C++中的继承(2)派生类的默认成员函数

在继承关系里面， 在派生类中如果没有显示定义这六个成员函数， 编译系统则会默认合成这六个默认的成员函数。

1、构造与析构函数的调用关系

调用关系先看一段代码：

class Base
{
    public :
    Base()
    {
        cout << "B() " << endl;
    }
    ~Base()
    {
        cout << "~B() " << endl;
    }
private:
    int _pri;
protected:
    int _pro;
public:
    int _pub;
};
class Derived : public Base
{
    public :
    Derived()
    {
        cout << "D() " << endl;
    }
    ~Derived()
    {
        cout << "~D() " << endl;
    }
private:
    int _d_pri;
protected:
    int _d_pro;
public:
    int _d_pub;
}; 
void Test()
{
    Derived d;
}
int main()
{
    Test();
    getchar();
    return 0;
}

输出结果为:

 

代码中，我们利用派生类Derived，创建了一个对象d，根据输出结果看到，貌似创建对象d的过程是：先调用基类的构造函数，再调用子类的构造函数；而析构对象时先调用子类的析构函数，再调用基类的析构函数。但是我们不能被表象所迷惑，我们转到反汇编来看看具体是怎么实现的：

我们看到创建对象d的时候是先调用Derived类的构造函数D()，但是在cout << "D() " << endl;这句代码执行之前，编译器还做了一堆的其他工作，其中最重要的是  call        Base::Base (0E41041h)这条指令它跳转到了基类中，如图示：

屏幕上输出：

B() 、D()即先执行cout << "B() " << endl;语句，再执行cout << "D() " << endl;语句，所以，才有屏幕上的结果。在析构对象d的时候先调用~D()但是没那么简单，再看图中

在语句cout << "~D() " << endl;执行完之后用掉call        Base::~Base (0E410D7h)指令跳转到~B()中 

此时~D()输出，接着~B()输出，然后，~D()才算执行完。

　　分析：基类是派生类的一部分，创建派生类对象时必须调用派生类构造函数，而派生类构造函数必须使用基类的构造函数。程序首先创建基类对象，所以基类对象在程序进入派生类构造函数之前被创建。实际上C++使用成员初始化列表语法来完成这项工作，即B()相当于在函数D()的初始化列表中被使用，如果不调用基类构造函数，程序将使用默认的基类构造函数。在执行完B()的函数体之后，继承的数据成员被初始化，执行D()函数体初始化新增的数据成员。析构对象时，先调用派生类的析构函数，执行完函数体析构完新增部分之后，使用基类的析构函数析构继承自基类的部分。所以才有上述现象。调用关系总结如下图：

　　总结：创建派生类对象时程序调用派生类构造函数，然后在初始化列表部分调用基类构造函数初始化继承的数据成员，而派生类构造函数主要初始化新增的数据成员。派生类总是调用一个基类构造函数。可以使用初始化列表语法指明要使用的基类构造函数，否则将使用默认的基类构造函数。派生类对象过期时，程序将先调用派生类析构函数，在函数体执行完之后调用基类析构函数。（可以看到，继承的数据成员生命周期长， 新增的数据成员生命周期短。）

构造函数带参情况

　　构造派生对象时，派生类构造函数默认调用参数缺省的基类构造函数，若基类构造函数带有参数，则派生类中必须显式定义构造函数，并在初始化列表中传参。本例中，若B()带有参数，则D()中必须显式定义构造函数并传参；

如图，B()带有参数，则D()中构造函数无参时编译不能通过。

传参之后可以编译用过。

　　当基类中显示定义构造函数，而派生类中没有定义构造函数，则使用默认合成的派生类构造函数，并在默认合成的派生类构造函数调用基类构造函数。即基类Base显式定义了构造函数，而派生类Derived中没有定义，则用默认合成的构造函数D()实例化对象，且在初始化参数列表部分调用基类构造函数B()。

同理当派生类中显示定义构造函数，而基类中没有定义构造函数，则在派生类构造函数中调用默认合成的基类构造函数。

2、拷贝构造函数

使用拷贝构造函数的情况有：

1. 将新的对象初始化为一个同类对象
2. 按值将对象传递给函数
3. 函数按值返回对象
4. 编译器生成临时对象

如果程序没有显式定义拷贝构造函数，编译器将自动生成一个。当然，如果想在派生类中构造基类对象，那么不仅仅可以用构造函数，也可以用拷贝构造函数

class Base
{
    public :
    Base()
    {
        cout << "B() " << endl;
    }
    ~Base()
    {
        cout << "~B() " << endl;
    }
private:
    int _pri;
protected:
    int _pro;
public:
    int _pub;
};
class Derived : public Base
{
    public :
    Derived()
    {
        cout << "D() " << endl;
    }
    Derived(const Derived &tp)
        :Base(tp)//拷贝构造函数
    {
        cout << "Derive()" << endl;
    }
    ~Derived()
    {
        cout << "~D() " << endl;
    }
private:
    int _d_pri;
protected:
    int _d_pro;
public:
    int _pub;
}; 
void Test()
{
    Derived d;
    Derived i(d);
}
int main()
{
    Test();
    getchar();
    return 0;
}

运行成功，输出结果为：

　　这里我没有给基类定义拷贝构造函数，但是编译器自动给基类生成了一个拷贝构造函数，因为我基类中定义的没有指针成员，所以浅拷贝可以满足我的要求，但是如果在基类成员中有指针变量，必须要进行显式定义拷贝构造函数，即进行深拷贝。不然会造成同一块内存空间被析构两次的问题。

3、赋值操作符

class Base
{};
int main()
{
    Base a;
    Base b = a;//初始化
    Base c;
    c = a;//赋值
}

　　默认的赋值操作符用于处理同类对象之间的赋值，赋值不是初始化，如果语句创建新的对象，则使用初始化，如果语句修改已有对象的值，则为赋值。 赋值运算符是不能被继承的，原因很简单。派生类继承的方法的特征与基类完全相同，但赋值操作符的特征随类而异，因为它包含一个类型为其所属类的形参。 
　　如果编译器发现程序将一个对象赋给同一个类的另一个对象，它将自动为这个类提供一个赋值操作符。这个操作符的默认版本将采用成员赋值，即将原对象的相应成员赋给目标对象的每个成员。 
　　如果对象属于派生类，编译器将使用基类赋值操作符来处理派生对象中基类部分的赋值，如果显示的为基类提供了赋值操作符，将使用该操作符。
　　注意：赋值运算和拷贝构造是不同的，赋值是赋值给一个已有对象，拷贝构造是构造一个全新的对象

将派生类对象赋给基类对象时：

class Base
{
   public:
     int data;
};
class Derive:public Base
{
   public:
     int d;
};
int main()
{
    Base a;
    Derive dd;
    a = dd;
}

上面的a=dd；语句将使用谁的赋值操作符呢。 实际上，赋值语句将被转换成左边的对象调用的一个方法

 a.operator=(dd);//左边的为基类对象

简而言之，可以将派生对象赋给基类对象，但这只涉及到基类的成员。如图示

 

基类对象赋给派生类对象。

class Base
 {
    public:
      int data;
};
 class Derive:public Base
 {
     public:
       int d;
 };
 int main()
 {
     Base a;
     Derive dd;
     dd = a;
 }

上述赋值语句将被转换为：

d.operator=(a); //Derive::operator=(const Derive&)
左边的对象为派生类对象，不过派生类引用不能自动引用基类对象，所以上述代码不能运行。或者运行出错。除非有函数Derive(const Base&){}

总结：

• 是否可以将基类对象赋给派生类对象，答案是也许。如果派生类包含了转换构造函数，即对基类对象转换为派生类对象进行了定义，则可以将基类对象赋给派生对象。
• 派生类对象可以赋给基类对象。