How to set base class members before derived class constructor is called?

Question

There is a base class for components of my application which provides some members and the functions Init() and Update() which must be overwritten.

class Component
{
public:
    void Set(type* Member1, type* Member2, type* Member3)
    {
        this->Member1 = Member1;
        this->Member2 = Member2;
        this->Member3 = Member3;
    }
    virtual void Init() = 0;
    virtual void Update() = 0;
    virtual ~Component() {}
protected:
    type* Member1;
    type* Member2;
    type* Member3;
};

For handeling the components, there is a manager. It first sets the members of a component and then calls Init() on it. Later on it can be used to update all assigned components but that isn't related to this question.

class Manager
{
public:
    void Add(string Name, Component* Component)
    {
        list[Name] = Component;
    }
    void Init(type* Member1, type* Member2, type* Member3)
    {
        for (auto i = list.begin(); i != list.end(); i++)
        {
            i->second->Set(Member1, Member2, Member3);
            i->second->Init();
        }
    }
    void Update()
    {
        for (auto i = list.begin(); i != list.end(); i++)
            i->second->Update();
    }
private:
    unordered_map<string, Component*> list;
};

I am not really happy with my implementation since I would like components to use their constructor for initialization instead overwriting the Init() function. But at construction time the base class member aren't available yet.

I know that I could pass the members through the derived class constructor, but I do not want specific components to care about their base class' members. That would look like the following but anyway I do not want that.

class Component
{
public:
    Component(type* Member1, type* Member2, type* Member3)
    {
        this->Member1 = Member1;
        this->Member2 = Member2;
        this->Member3 = Member3;
    }
    virtual void Update() = 0;
    virtual ~Component();
protected:
    type* Member1;
    type* Member2;
    type* Member3;
};

class Specific : public Component
{
public:
    Specific(type* Member1, type* Member2, type* Member3) : Component(Member1, Member2, Member3)
    {

    }
    void Update()
    {

    }
};

So how can I insure that the base class members are initialized before calling the constructor of the derived class?

When you Member initializer list the Base class constructor will be called before you enter the body of the derived class constructor. — Alok Save
"I do not want specific components to care about their base class' members" Then why on earth did you declare them as protected? — Lundin
@Lundin. Specific components should use them but shouldn't care about their initialization. — danijar
@AlokSave. I know that's why I told you that I would not prefer that solution since I don't want a specific component to care about initialization of these base class members. — danijar
I should just note that protected attributes are a design smell by themselves, and it sounds like you may be using public inheritance as a hybrid interface/containment rather than just to apply an interface. With more information on your underlying problem (and why the members need to be set later for example) we could probably provide an alternate approach that would address your conerns. — Mark B

Bart van Ingen Schenau Bart van Ingen Schenau · Accepted Answer · 2013-01-22T15:21:59

You don't really have a choice. Either the derived class knows about the initialisation needs of the base class (because the base class needs that information in its constructor/initialisation function), or you have to move the derive-class' initialisation out of its constructor (to be called by the client after it initialised the base class).

If the list of members that need to be set on the base class is long, you could package them all in a structure and pass that, via the derived class, to the base class.

How to set base class members before derived class constructor is called?

3 Answers