如何在STL容器中存储具有抽象模板类型的抽象模板类？

Question

I hope the title is not misleading, but I could not find the right language to define my problem in one question.

Recently I've been trying to implement "CQRS Command Handler" design pattern using C++. I have 2 hierarchies that I have to marry together:

• ICommand

   struct ICommand { virtual ~ICommand() = default; }; struct SampleCommand : ICommand { int sampleParameter; SampleCommand() : sampleParameter(0) { } explicit SampleCommand(const int sampleParameter) { this->sampleParameter = sampleParameter; } }; 

• ICommandHandler

   template<typename T, typename = std::enable_if_t<std::is_base_of<ICommand, std::decay_t<T>>::value>> struct ICommandHandler { virtual void Handle(std::shared_ptr<T> command) = 0; virtual ~ICommandHandler() = default; }; class SampleCommandHandler : public ICommandHandler<SampleCommand> { public: void Handle(std::shared_ptr<SampleCommand> command) override { std::cout << "sampleParameter " << command->sampleParameter << std::endl; } }; 

Last piece I need to implement is a dispatcher which takes a command, finds a handler and delegates a command to a found handler. First idea that come to my mind was to expose some handler registering API in dispatcher and write dispatch method that would simply try to dynamic_cast all the registered handlers and if some cast was successful it would invoke found handler as shown below:

class Dispatcher
{
public:

template<typename T>
void Dispatch(std::shared_ptr<T> command)
{
    auto handler = std::find_if(std::begin(_handlers), std::end(_handlers), [](auto handler)
    {
        return dynamic_cast<ICommandHandler<T>*>(handler);
    });

    if(handler != std::end(_handlers))
    {
        (*handler)->Handle(command);
    }
}

private:
    std::vector<?> _handlers;
};

The question is: what type should "_handlers" std::vector store to make the Dispatcher::Dispatch method work fine and if this is even possible?

What I have tried so far:

• std::vector< ICommandHandler *> - Did not compile, because casting a concrete handler to ICommandHandler< ICommand> *> is not possible.

   Error C2440 'initializing': cannot convert from 'SampleCommandHandler *' to 'ICommandHandler<ICommand,void> *' 

• std::vector< void* > - Did not compile as dynamic_cast cannot be applied to void*

Answer 1

You have a bunch of pointless (at least to me) polymorphism here; I'd split the container of handlers based on what they handle, instead of using one vector. Like a map/unordered map from typeindex to handler; or, have a fixed set of types to handle.

But to solve the problem asked:

struct ICommandHandlerBase{
  virtual ~ICommandHandlerBase(){};
};
template<typename T, typename = std::enable_if_t<std::is_base_of<ICommand, std::decay_t<T>>::value>>
struct ICommandHandler:ICommandHandlerBase
{

now store a vector of ICommandHandlerBase* or unique_ptr<ICommandHandlerBase> .

Answer 2

Certainly use a map or unordered map to do the look-up. If you must, you could use a (unordered) set with a custom comparator. Though that doesn't answer your question :-)

Assuming your handlers really are polymorphic, then your map or set will have to be pointers to the interface ICommandHandler. They should not be raw pointers, but could be some flavour of smart pointer.

Using std::shared_ptr means that your handler object lifetime is guaranteed while processing an event - if it also takes a shared_ptr, even if the event is removed from the mapping (either inside the handler or by another thread or handler), but comes with added internal complexity.

The implementation of std::unique_ptr is much simpler and can work well when you know a handler can't be interrupted. Note that the client code only sees the raw pointer - it must not steal the unique_ptr!