Inherited Constructors in C++

前端 未结 2 1101
误落风尘
误落风尘 2021-01-07 02:20

I\'m trying to practice Inheriting Constructors in C++. I have compiled and run following program in gcc and it\'s working fine.

#include<         


        
2条回答
  •  醉梦人生
    2021-01-07 02:46

    From cppreference http://en.cppreference.com/w/cpp/language/using_declaration
    If the using-declaration refers to a constructor of a direct base of the class being defined (e.g. using Base::Base;), constructors of that base class are inherited, according to the following rules:

    1) A set of candidate inheriting constructors is composed of
    a) All non-template constructors of the base class (after omitting ellipsis parameters, if any) (since C++14)
    b) For each constructor with default arguments or the ellipsis parameter, all constructor signatures that are formed by dropping the ellipsis and omitting default arguments from the ends of argument lists one by one
    c) All constructor templates of the base class (after omitting ellipsis parameters, if any) (since C++14)
    d) For each constructor template with default arguments or the ellipsis, all constructor signatures that are formed by dropping the ellipsis and omitting default arguments from the ends of argument lists one by one
    2) All candidate inherited constructors that aren't the default constructor or the copy/move constructor and whose signatures do not match user-defined constructors in the derived class, are implicitly declared in the derived class. The default parameters are not inherited:

    struct B1 {
        B1(int);
    };
    struct D1 : B1 {
        using B1::B1;
    // The set of candidate inherited constructors is 
    // 1. B1(const B1&)
    // 2. B1(B1&&)
    // 3. B1(int)
    
    // D1 has the following constructors:
    // 1. D1()
    // 2. D1(const D1&) 
    // 3. D1(D1&&)
    // 4. D1(int) <- inherited
    };
    
    struct B2 {
        B2(int = 13, int = 42);
    };
    struct D2 : B2 {
        using B2::B2;
    // The set of candidate inherited constructors is
    // 1. B2(const B2&)
    // 2. B2(B2&&)
    // 3. B2(int = 13, int = 42)
    // 4. B2(int = 13)
    // 5. B2()
    
    // D2 has the following constructors:
    // 1. D2()
    // 2. D2(const D2&)
    // 3. D2(D2&&)
    // 4. D2(int, int) <- inherited
    // 5. D2(int) <- inherited
    };
    

    The inherited constructors are equivalent to user-defined constructors with an empty body and with a member initializer list consisting of a single nested-name-specifier, which forwards all of its arguments to the base class constructor.

    It has the same access as the corresponding base constructor. It is constexpr if the user-defined constructor would have satisfied constexpr constructor requirements. It is deleted if the corresponding base constructor is deleted or if a defaulted default constructor would be deleted (except that the construction of the base whose constructor is being inherited doesn't count). An inheriting constructor cannot be explicitly instantiated or explicitly specialized.

    If two using-declarations inherit the constructor with the same signature (from two direct base classes), the program is ill-formed.

提交回复
热议问题