第11课继承构造函数和委派构造函数

时间 2019-11-06

原文原文链接

1、继承构造函数ios

（一）函数继承与同名覆盖c++

　　1. 派生类能够自动得到基类的成员变量和接口（虚函数和纯虚函数，这里指都是public派生），这体现了类的继承性。编程

　　2. 若是基类的非虚函数在派生类被重写，则将发生同名覆盖现象。即基类函数在派生类中会被同名函数隐藏，从而不可见。特别是构造函数也不例外，基类的构造函数在派生类中将不可见，若是须要这些构造函数，则需在派生类中显式声明这些接口。函数

（二）继承构造函数this

　　1. C++0x中若是派生类要使用基类成员函数，能够经过using声明来完成。C++11中，这种用法被扩展到构造函数，即子类能够经过使用using来声明继承基类的构造函数。可是一旦使用继承构造函数，编译器就不会再为派生类生成默认构造函数了。编码

　　2. 继承构造函数只会初始化基类中的成员变量，对于派生类中的成员变量则需由派生类自行初始化（如“就地初始化”、初始化列表等）。spa

　　3. 若是基类构造函数的参数有默认值，编译器会产生多个构造函数，并被派生类继承（含默认值）。设计

　　4. 在多继承体系中，若是某些基类构造函数参数个数和类型都相同，那么在继承构造函数时会发生“冲突”，能够在派生类中显式定义那些“冲突”的构造函数，从而阻止隐式生成相应的继承构造函数来解决冲突。code

　　5. 若是基类的构造函数被声明为private，或者派生类是从基类中虚继承的，就不能在派生类中声明继承构造函数。对象

　　6. C++11中继承构造函数与派生类的各类类默认函数同样，是隐式声明的。即若是一个继承构造函数不被相关代码使用，编译器不会为其产生真正的函数代码。这比显式声明函数更加节省目标代码空间。

【编程实验】继承构造函数

#include <iostream>
using namespace std;

//1. 基类
struct Base
{
    Base() { cout << "Base()" << endl; }
    Base(int i) { cout << "Base(int i)" << endl; }
    Base(double d, int i) { cout << "Base(double d, int i)" << endl; }

    Base(float f, int i, const char* c) 
    {
        cout << "Base(float f, int i, const char* c) " << endl;
    }

    void func(double i)  //非虚函数
    {
        cout << "Base::func(double i) : " << i << endl;
    }
};

//1.1 显式声明构造函数
struct NonUsingDerived : public Base
{
    int d{ 0 }; //就会初始化派生类成员

    //注意：
    //1. 基类自定义了构造函数，编译器再也不为派生类提供默认构造函数
    //2. 基类的构造函数在派生类中是被隐藏的，没法“透传”给基类。为了使用基类构
    //   造函数，需在派生类中一个一个地显式声明（明显很笨拙），以下
    NonUsingDerived(int i): Base(i){ cout << "NonUsingDerived(int i)" << endl; }
    NonUsingDerived(double d, int i) : Base(d, i) { cout << "NonUsingDerived(double d, int i)" << endl; }

    NonUsingDerived(float f, int i, const char* c) : Base(f, i, c)
    {
        cout << "NonUsingDerived(float f, int i, const char* c) " << endl;
    }

    void func(int i)  //与基类非虚函数同名，这里会将基类同名函数隐藏，从而不可见。
    {
        cout <<"NonUsingDerived::func(int) : " << i << endl;
    }
};

//1.2 使用using继承构造函数
struct UsingDerived : public Base
{
    int d{ 0 }; //就会初始化派生类成员

    //注意：使用using继承基类的构造函数 
    using Base::Base;  //继承构造函数

    using Base::func; //使用基类void func(double)函数
    void func(int i)  //
    {
        cout << "UsingDerived::func(int) : " << i << endl;
    }   
};

//2. 带默认值的构造函数
struct Parent
{
    int a;
    double d;
    Parent(int a = 3, double d = 2.4) : a(a), d(d)
    {
        cout << "Parent(int, double)" << endl;
    }
    void show()
    {
        cout <<"a = " << a << ", d = " << d<< endl;
    }
};

struct Child : public Parent
{
    //因为基类构造函数带默认参数值，使用using继承时，其实分解为
    //Parent(int,double)、Parent(int)、Parent()等并继承下来(含默认值)。
    using Parent::Parent; //继承基类的构造函数
};

int main()
{
    //1. 显式声明构造函数与using的比较
    //NonUsingDerived d1;  //编译失败，派生类没显式声明无参构造函数。
    NonUsingDerived d2(1);
    d2.func(1);    //调用派生类本身的void func(int)
    d2.func(1.5);  //经隐式转换，仍会调用派生类的void func(int)，由于基类void func(double)被隐藏。

    UsingDerived d3; //ok, 继承了基类的无参构造函数。
    UsingDerived d4(1.0, 2); 
    d4.func(1);   //调用派生类本身的void func(int)
    d4.func(1.5); //调用基类的void func(double)

    cout <<"----------------------------------------------------------------------------" << endl;
    //2. 带默认值的构造函数的继承
    Child c1;
    c1.show();

    Child c2(4);
    c2.show();

    Child c3(4, 1.0);
    c3.show();
    
    return 0;
}
/*输出结果
Base(int i)
NonUsingDerived(int i)
NonUsingDerived::func(int) : 1
NonUsingDerived::func(int) : 1
Base()
Base(double d, int i)
UsingDerived::func(int) : 1
Base::func(double i) : 1.5
----------------------------------------------------------------------------
Parent(int, double)
a = 3, d = 2.4
Parent(int, double)
a = 4, d = 2.4
Parent(int, double)
a = 4, d = 1
*/

2、委派构造函数

（一）概述

　　1. 在C++11中，所谓委派构造，就是指委派函数将构造任务委托给某个目标构造函数来完成类构造的一种方式。通俗地讲，就是容许构造函数经过初始化列表方式来调用同一个类中的另外一个构造函数

　　2. 委派构造函数和目标构造函数是调用者和被调用者的关系。

　　3. 在多构造函数类中，经过委派给其余构造函数，将使编码更简洁。

　　4. 目标构造函数是一个构造函数，而不是普通的成员函数。

（二）委派构造函数

　　1. 做为委派的目标构造函数，通常会抽象成最为“通用”的基本版本，以方便其余构造函数的调用。

　　2. 委派构造函数在初始化列表位置进行构造和委派的。

　　3. 在委派构造函数的初始化列表中只容许有目标构造函数，不能有其余项的初始化。若是委派构造函数要给变量赋初值，初始化代码必须放在函数体中。

　　4. 目标构造函数老是先于委派构造函数执行（这是因为C++中初始化列表老是先于构造函数被调用）。所以避免目标构造函数和委派构造函数体中初始化一样的成员一般是必要的。

　　5. 当构造函数较多时，可能拥有不止一个委派构造函数，而一些目标构造函数极可能也是委派构造函数。所以，委派构造函数关系中造成链状的构造关系，但不能造成“委派环”。

（三）委派构造函数的应用

　　1. 模板构造函数：经过构造函数模板来产生目标构造函数，再利用委派使构造函数具备泛型编程的能力。

　　2. 异常处理方面，若是在委派构造函数中使用try的话，那么从目标构造函数产生的异常，均可以在委派构造函数中被捕捉到。

　　　　（1）这是一种在构造函数体外catch异常的方式，C++会自动从新将异常抛出给对象建立者，哪怕咱们没有显式throw该异常。

　　　　（2）这种构造函数体外的try-catch语句，能够同时捕获基类或数据成员抛出的异常。此外还有一个用途，就是用来转换捕捉到的异常对象。

【编程实验】委派构造函数

#include <iostream>
#include <vector>
#include <deque>
#include <list>
using namespace std;

//1. 委派构造函数
//1.1 不使用委派构造的类
class Info1
{
private:
    int type;
    char name;
    void initRest()
    {
        type += 1; //其它初始化任务
    }
public:
    //三个构造函数初除了初始化列表不一样，函数体都是同样的。若是initRest代码量大，存在
    //严重的代码重复现象。
    Info1() : type(1), name('a') { initRest(); }
    Info1(int i) : type(i), name('a') { initRest(); } //type(i)先于initRest执行！
    Info1(char c) : type(1), name{ 'e' }{initRest(); }

    void print()
    {
        cout << "type = " << type << ", name = " << name << endl;
    }
};

//1.2 使用委派构造函数
class Info2
{
private:
    int type;
    char name;

    //目标构造函数（这里通常设为private）
    Info2(int i, char e) : type(i),name(e)
    {
        type += 1;  //其它初始化
    }
public:
    //三个构造函数为委派构造函数，会将构造任务委托相应的目标构造函数！
    Info2() : Info2(1, 'a') {}    //委派给Info2(int i, char e)目标函数去构造
    Info2(char c) : Info2(1, c){} //委派给Info2(int i, char e) 去构造

    //Info2(int i) : Info2(),type(i) {} //编译失败！委派构造初始化列表不能有目标构造函数之外的成员！
    Info2(int i) : Info2() { type = i;} //委派给Info2() 去目标构造函数

    void print()
    {
        cout << "type = " << type << ", name = " << name << endl;
    }
};

//2. 构造函数模板+委派，使构造函数具备泛型编程能力
class TDConstructed  //Template delegate construct
{
private:
    std::list<int> ls;

    //构造函数模板：构造一个容器，用于采集从first到last之间的元素（T为迭代器类型）
    template<typename T> TDConstructed(T first, T last) : ls(first, last)
    {
    }
public:
    //利用委派，使该类能接受多种容器对其进行初始化。
    TDConstructed(vector<short>& v) : TDConstructed(v.begin(), v.end()) {}
    TDConstructed(deque<int>& d) : TDConstructed(d.begin(), d.end()) {}

    void print()
    {
        for (const auto& elem : ls)
        {
            cout << elem << " ";
        }
        cout << endl;
    }
};

class Widget
{
public:
    Widget() { cout << "Widget() : " << this << endl; }
    ~Widget() {cout << "~Widget() : " << this << endl;}
};

//3. 利用委派构造来捕获构造函数出现的异常
class ExceptDemo  //Delegate Constructor Exception
{
private:
    int type;
    double data;
    Widget w;
    
    //目标构造函数
    ExceptDemo(int i, double d) : type(i), data(d)
    {
        cout << "going to throw!" << endl;
        throw 0;  
    }
public:
    //构造函数块外的catch语句（上面这种）即便没有显示地从新抛出异常，c++也会自动抛出
    //委派给ExceptDemo(int, double)去构造。
    ExceptDemo(double d) try : ExceptDemo(1, d)   //注意，try块是整个构造函数体，而异常是构造函数体外被catch！
    {                                             //这种方式能够同时捕获基类或数据成员抛出的异常！
        //目标构造函数抛出异常，这里没机会执行！这样设计是合理的，当构造函数出现异常
        //不该该再继续执行这段代码去构造了。
        cout << "Run the body." << endl; 
        //其余初始化
    }
    catch (...)
    {
        cout << "ExceptDemo(): caught exception." << endl; //捕获到异常！！！执行到这里。（注意，此时成员对象Widget会被释放）

        //.....             //这里能够作一些清理工做，如delete一些堆对象操做，关闭一些句柄等操做
        //throw;            //标准的作法是：在这里继续传递异常给对象的建立者。但这种在构造函数块外的catch语句，即便没有
                            //显式地从新抛出异常，c++也会自动将异常从新抛出。
    }

    ~ExceptDemo()
    {        
        cout <<"~ExceptDemo()" << endl;
    }
};

int main()
{
    //1. 委派构造函数和目标构造函数
    Info1 obj1(3);
    obj1.print();  //type = 4, name = a

    Info2 obj2(3);
    obj2.print();  //type = 3, name = a（因为目标构造函数先执行，即type=4，但
                   //随后执行委派构造函数，又执行type =i，即type又变成3。

    vector<short> v = { 1,2,3,4,5 };
    deque<int> d = { 6,7,8,9 };

    //2. 构造函数模板化
    TDConstructed td1(v);
    td1.print();

    TDConstructed td2(d);
    td2.print();

    //3. 在委派构造函数中捕获构目标构造函数异常
    try {
        ExceptDemo ed(1.2);
    }
    catch (...)
    {
        cout <<"main()：caught exception." << endl;
    }
    
    return 0;
}
/*输出结果
type = 4, name = a
type = 3, name = a
1 2 3 4 5
6 7 8 9
Widget() : 003BF880
going to throw!
~Widget() : 003BF880
ExceptDemo(): caught exception.
main()：caught exception.
*/

第11课 继承构造函数和委派构造函数

第11课继承构造函数和委派构造函数