Initialize Derived class member variable before calling Base class constructor. Is this UB?

Question

I would like to initialize a member variable of a Derived class, and after that pass it to the Base class constructor. I came up with the solution below (also here: http://cpp.sh/4uu4q)

1) Does the following code have a defined or an undefined behavior (UB) ?

2) Is what I am attempting to do an indication of a bad design?

struct Data {
    int fValue;

    Data( int value = -1 ) : fValue( value )
    {}
};


struct Base {
    Base( const std::unique_ptr<Data> & derivedData ) {
        std::cout << "Constructing Base derivedData=" << derivedData->fValue << std::endl;
    }
};


struct Derived : public Base {
    std::unique_ptr<Data> fData = std::move( fData );

    Derived() : Base( ConstructData() )
    {}

    const std::unique_ptr<Data> & ConstructData() {
        fData.release();
        fData.reset( new Data(777) );
        std::cout << "in ConstructData: fData->fValue =" << fData->fValue << std::endl;
        return fData;
    }
};


int main() {
    Derived d;
    std::cout << "In main: d.fData->fValue =" << d.fData->fValue << std::endl;
    return 0;
}

2) yes, why does your base class need to know about the derived one in its constructor? — 463035818_is_not_an_ai, Sep 21 '16 at 12:28
The derived class is not constructed until after its base classes are constructed. This is UB. — Sam Varshavchik, Sep 21 '16 at 12:30
You operate fData before it's constructor has been called, so it is an UB. — Alexey Guseynov, Sep 21 '16 at 12:33
Base class try to initial derived class member variable or even change derived class's member variable is a kind of breaking encapsulation. — Tongxuan Liu, Sep 21 '16 at 14:46

Ami Tavory · Accepted Answer · 2016-09-21T12:41:00.463

I would like to initialize a member variable of a Derived class, and after that pass it to the Base class constructor.

In C++, the order of construction is of the base part(s) before the derived parts. This is because it is far more common for the derived parts to (potentially) be constructed in terms of the base parts. In order to make this well-defined, the base-then-derived order is specified. Using derived in the base is undefined, therefore.

If you want your base to use derived members, there's a way to ensure the order is OK. Make the "members" base classes too. Note that boost::base_from_member is built exactly for making this more convenient.

Say you have some

class member_type{};

And you'd like to have derived have a member_type member, and derive from base. Then you could use:

class derived : 
    private boost::base_from_member<member_type>,
    public base {
    using my_member_type = private boost::base_from_member<member_type>;

public:
    derived();
};

Note that now derived subclasses both my_member_type and base (in that order). Hence, the latter can use the former in its construction.

derived::derived() : 
    my_member_type{3},
    base{my_member_type::member} {
}

Initialize Derived class member variable before calling Base class constructor. Is this UB?

1 Answers1