第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
*/

#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.
*/