Question

Hi,

I’m writing a component based class with a container, but after thinking of many different approaches, I can’t find one that follows really what I want.

Here is an example of the general idea :

And the code I already wrote :

// Abstract class Component
class Component
{
public :
    virtual ~Component() = 0;
    virtual int GetResult() = 0;
};


class AddComponent : Component
{
public :
    int GetResult() { return input1->GetResult() + input2->GetResult(); }

    void SetInput1(Component* c) { input1 = c; }
    void SetInput2(Component* c) { input2 = c; }

private :
    Component* input1;
    Component* input2;
};

class ConstComponent : Component
{
public :
    int GetResult() { return value; }

    void SetValue(int x) { value = x; }

private :
    int value;
};

class SignComponent : Component
{
public :
    int GetResult() { return sign(input->GetResult()); }

    void SetInput(Component* c) { input = c; }

private :
    Component* input;
};


class Container
{
public :
    Container();
    ~Container();

    void SetRootComponent(Component* c) { rootComponent = c; }

    int GetResult() { return rootComponent->GetResult(); }

    AddComponent* AddComponentAdd();
    ConstComponent* ConstComponentAdd();
    SignComponent* SignComponentAdd();

private :
    Component* rootComponent;
    std::vector<Component*> components;
};


void main(void)
{
    // Create container
    Container container = Container();

    // Create components
    SignComponent*    cSign = container.AddComponentSign();
    AddComponent*      cAdd = container.AddComponentAdd();
    ConstComponent* cConst1 = container.AddComponentConst();
    ConstComponent* cConst2 = container.AddComponentConst();

    // Link components
    cSign->SetInput(cAdd);
    cAdd->SetInput1(cConst1);
    cAdd->SetInput2(cConst2);
    cConst1->SetValue(-5);
    cConst2->SetValue(3);

    // Set root component for container
    container.SetRootComponent(cSign);

    // Compute
    int result = container.GetResult();
}

This doesn’t even compile, because of the cast of “XComponent” to “Component”, which is abstract. I’m pretty sure there is a much better (and simpler ?) way to do it anyway, but I’m out of ideas.

Answer 1

The default inheritance for class is private:

class ConstComponent : Component

For all subclasses of Component you need public inheritance:

class ConstComponent : public Component

if you are attempting to insert new instances of the subclasses into the std::vector<Component*> (which I think you are).
private inheritance is not an is-a relationship, but is a has-a relationship. See How are “private inheritance” and “composition” similar? .