C++11委托构造函数和继承构造函数的实现

class MyClass {
public:
    // 目标构造函数
    MyClass(int param1, int param2) { 
        // 构造函数的具体实现 
    }
    // 委托构造函数
    MyClass(int param) : MyClass(param, 0) { 
        // 委托给另一个构造函数完成初始化 
    }
}; 

#include <iostream>
using namespace std;
class Test {
public:
    Test() {}; 
    Test(int max) { 
        this->m_max = max > 0 ? max : 100; 
    }
    Test(int max, int min) : Test(max) { 
        this->m_min = min > 0 && min < max ? min : 1; 
    }
    Test(int max, int min, int mid) : Test(max, min) { 
        this->m_middle = mid < max && mid > min ? mid : 50; 
    }
    int m_min; 
    int m_max; 
    int m_middle; 
}; 
int main() { 
    Test t(90, 30, 60); 
    cout << "min: " << t.m_min << ", middle: " << t.m_middle << ", max: " << t.m_max << endl; 
    return 0; 
}

class MyClass {
public:
    MyClass(int param1) : MyClass(param1, 0) { 
        // 委托给另一个构造函数完成初始化 
    }
    MyClass(int param1, int param2) : MyClass(param1) { 
        // 错误:形成了闭环 
    }
}; 

class Test {
public:
    Test(int max) { 
        this->m_max = max > 0 ? max : 100; 
    }
    Test(int max, int min) { 
        Test(max); // 错误，编译器会报错，提示形参max被重复定义 
        this->m_min = min > 0 && min < max ? min : 1; 
    }
}; 

class Test {
public:
    Test(int max, int min) : Test(max), m_max(max) { 
        // 错误，使用了委托构造函数就不能再次m_max初始化了 
        this->m_min = min > 0 && min < max ? min : 1; 
    }
}; 

class Base {
public:
    Base() { 
        // 默认构造函数的实现 
    }
    Base(int value) { 
        // 带参数的构造函数实现 
    }
}; 
class Derived : public Base {
public:
    using Base::Base; // 继承基类的所有构造函数 
}; 

#include <iostream>
#include <string>
using namespace std;
class Base {
public:
    Base(int i) : m_i(i) { }
    Base(int i, double j) : m_i(i), m_j(j) { }
    Base(int i, double j, string k) : m_i(i), m_j(j), m_k(k) { }
    int m_i; 
    double m_j; 
    string m_k; 
}; 
class Child : public Base {
public:
    using Base::Base; 
}; 
int main() { 
    Child c(520, 13.14, "i love you"); 
    cout << "int: " << c.m_i << ", double: " << c.m_j << ", string: " << c.m_k << endl; 
    return 0; 
}

struct Base1 {
    Base1() = default; 
    Base1(const std::string&); 
    Base1(std::shared_ptr<int>); 
}; 
struct Base2 {
    Base2() = default; 
    Base2(const std::string&); 
    Base2(int); 
}; 
// 错误: D1 试图从两个基类中都继承D1::D1(const string&) 
struct D1 : public Base1, public Base2 {
    using Base1::Base1; //从 Base1 继承构造函数 
    using Base2::Base2; //从 Base2 继承构造函数 
}; 

struct D2 : public Base1, public Base2 {
    using Base1::Base1; //从 Base1 继承构造函数 
    using Base2::Base2; //从 Base2 继承构造函数 
    // D2 必须自定义一个接受 string 的构造函数 
    D2(const string& s) : Base1(s), Base2(s) { }
    D2() = default; // 一旦 D2 定义了它自己的构造函数，则必须出现 
};