CODEWITHSUNDEEP
c++polymorphism
Simon Elliott
Simon Elliott

Reputation: 2117

c++ design: avoid iterating over types with an existing class hierarchy

Please consider the following (simplified) class hierarchy and processing functions:

struct msgBase
{
    virtual int msgType() const=0;
};

struct msgType1:public msgBase
{
    virtual int msgType() const{return 1;}
};

struct msgType2:public msgBase
{
    virtual int msgType() const {return 2;}
};

void process(const msgType1& mt1)
{
    // processing for message type 1
}

void process(const msgType2& mt2)
{
    // processing for message type 2
}

void process(const msgBase& mbase)
{
    switch(mbase.msgType())
    {
    case 1:
        process(static_cast<const msgType1&>(mbase));
        break;
    case 2:
        process(static_cast<const msgType2&>(mbase));
        break;
    }
}

In an integrated design, msgBase would be given a virtual "process" method, to avoid needing to iterate over the types.

If it's not possible or desirable to modify any of the classes, are there any alternatives to iterating over the types?

I've experimented with a decorator/factory pattern where a parallel hierarchy of classes encapsulates the given classes, and implements the necessary virtual functions, but this results in an awful lot of boilerplate, and the factory function still needs to iterate over the types!

I could replace the switch statement with a series of dyamic_casts, but that still leaves the same weaknesses.

Upvotes: 2

Views: 250

Answers (3)

Felix Glas
Felix Glas

Reputation: 15524

If you can't modify the classes then you can use decorators to get polymorphic type deduction.

struct DecorBase {
    DecorBase(msgBase& b) : b_(b) {}
    virtual ~DecorBase() {}
    virtual void process() = 0;
    msgBase& b_;
};

struct DecorType1 : public DecorBase {
    DecorType1(msgType1& t1) : DecorBase(t1) {}
    void process() override {
        std::cout << "Processing Type 1" << std::endl;
    }
};

struct DecorType2 : public DecorBase {
    DecorType2(msgType2& t2) : DecorBase(t2) {}
    void process() override {
        std::cout << "Processing Type 2" << std::endl;
    }
};

And use it like this:

msgType1 t1;
msgType2 t2;
DecorType1 dt1(t1); // Wrap objects in respective decorator.
DecorType2 dt2(t2);

DecorBase& base = dt2;
base.process();     // Uses polymorphism to call function in derived type.

This will require you to write a decorator for every derived type but at least you don't have to iterate over all types during the function call.

Upvotes: 1

catscradle
catscradle

Reputation: 1719

Something like this could work:

These classes are used to do the casting automatically:

struct dispatcher_base {
    virtual void process(const msgBase&) = 0;
};

template <class T>
struct dispatcher_impl : dispatcher_base {
    void process(const msgBase& b) override {
        ::process(static_cast<const T&>(b));
    }
};

We'll store them in a map:

auto g_table = std::map<int, std::unique_ptr<dispatcher_base>>{};

But now you have to initialize this table somewhere:

template <class T>
void register_msg() {
    g_table[T{}.msgType()].reset(new dispatcher_impl<T>{});
}
...
register_msg<msgType1>();
register_msg<msgType2>();

You can add an assert to register_msg to make sure that msgTypes are unique.

Your process function will look like this:

void process(const msgBase& b) {
    assert(g_table.find(b.msgType()) != g_table.end());
    g_table[b.msgType()]->process(b);
}

You can replace assert with any other logic of course.

Upvotes: 1

wrongu
wrongu

Reputation: 580

As requested by Simon, here is what I mean by CRTP:

typedef <class Derived>
struct msgBase
{
    virtual void process(){
        // redirect the call to the derived class's process()
        static_cast<Derived*>(this) -> process();
};

struct msgType1:public msgBase<msgType1>
{
    void process(){
        // process as per type-1
    }
};

struct msgType2:public msgBase<msgType1>
{
    void process(){
        // process as per type-2
    }
};

What's happening here? Consider this case:

msgBase* msg = new msgType1();
msg->process();

normally (without CRTP) this would only call msgBase::process(). But now, msgBase "knows" about msgType1 using the template, so it is redirected to msgType1::process at compile time.

Upvotes: 2

Related Questions