C++ Lookup table for derived classes - c++

Question

I have a wrapper class holding a bunch of derived class objects by means of a vector of references to a common base class. During runtime, the Child objects are created based on user input.
#include <iostream>
#include <vector>
#include <memory>
#include <type_traits>
class Base {
public:
virtual void run() = 0;
};
class Wrapper {
public:
std::vector<std::shared_ptr<Base>> blocks;
template <class Child>
auto create() -> std::shared_ptr<Child>
{
auto block = std::make_shared < Child > ();
blocks.emplace_back(block);
return std::move(block);
}
template <typename A, typename B>
void connect(A a, B b)
{
using connectionType = typename A::element_type::out;
connectionType* port = new connectionType;
a.get()->ptr_out = port;
b.get()->ptr_in = port;
}
};
class Child_1 : public Base {
public:
using in = int;
using out = float;
out* ptr_out;
in* ptr_in;
void run() { std::cout<<"running child 1\n"; *ptr_out = 1.234;};
};
class Child_2 : public Base {
public:
using in = float;
using out = bool;
out* ptr_out;
in* ptr_in;
void run() { std::cout<<"running child 2\ngot: "<<*ptr_in; };
};
int main () {
Wrapper wrapper;
/* read config file with a list of strings of which types to create */
std::vector < std::string > userInput;
userInput.push_back("Type 0");
userInput.push_back("Type 1");
for (auto input:userInput)
{
if (input == "Type 0")
wrapper.create < Child_1 > ();
else if (input == "Type 1")
wrapper.create < Child_2 > ();
/* and so on */
}
/* read config file with a list of pairs of which objects to connect */
std::vector < std::pair < int, int >>connections;
connections.push_back(std::make_pair(0, 1));
// e.g. user wants to connect object 0 with object 1:
for (int i = 0; i < connections.size (); i++)
{
auto id0 = connections[i].first; // e.g. 0
auto id1 = connections[i].second; //e.g. 1
// this will not work because Base has no typename in / out:
// wrapper.connect (wrapper.blocks[id0], wrapper.blocks[id1]);
// workaround:
wrapper.connect(
std::dynamic_pointer_cast<Child_1>(wrapper.blocks[id0]),
std::dynamic_pointer_cast<Child_2>(wrapper.blocks[id1]));
}
wrapper.blocks[0].get()->run();
wrapper.blocks[1].get()->run();
return 0;
}
Now, I'm only able to store a vector of Base objects which cannot hold the different in/out types of each derived object. When I want to connect the derived objects (which are stored as Base class objects), I need to dynamic_pointer_cast them back into their derived class. What's the most efficient way to do this?
There are a few ways I could think of - none of which seem to be possible (to my knowledge) with C++:
Have some kind of lookup-table / enum which returns a type to cast to; I could then create a map from the user input "Type 0" etc to the type and cast accordingly.
Have some kind of lambda-like expression that would return the correctly casted pointer type such that I can call wrapper.connect( lambda_expression(...), lambda_expression(...) ).
Brute force: check for each possible combination of user inputs and call the connect function with the dynamic_pointer_cast (as shown in the coding example). This will very likely not be suitable for my real-world application (currently using about 25 such classes) because it would result in a huge number of not maintainable function calls...
Somehow give the generic in/out types to the Base class but I can't think of any method to do so.
I really hope I'm missing something obvious. Any help is much appreciated.

Answer 1

This looks like a typical case of double dynamic dispatching, however there is a possible simplification in that the output and input types must match. Hence, here is sort of a half-Visitor pattern.
First, we extract the concepts of input and output types into classes so that they can be targeted by dynamic_cast:
template <class In_>
struct BaseInput {
using In = In_;
std::shared_ptr<In> ptr_in;
};
template <class Out_>
struct BaseOutput {
using Out = Out_;
std::shared_ptr<Out> ptr_out;
};
Note: I've swapped in std::shared_ptrs rather than letting raw owning pointers in the wild.
From there, we can declare a virtual connectTo function in Base to get the first level of dynamic dispatching:
class Base {
public:
virtual ~Base() = default;
virtual void run() = 0;
virtual void connectTo(Base &other) = 0;
};
Note: I have added a virtual destructor to Base. AFAICT it is superfluous thanks to std::shared_ptr's type erasure, however Clang was spewing warnings at me and I wasn't willing to chase them down.
Finally, the second dynamic lookup can be done from Base::connectTo's override, which I have factored out in a handy template:
template <class In, class Out>
struct Child
: Base
, BaseInput<In>
, BaseOutput<Out> {
void connectTo(Base &other_) override {
// Throws std::bad_cast if other_'s input type doesn't match our output type
auto &other = dynamic_cast<BaseInput<Out> &>(other_);
this->ptr_out = other.ptr_in = std::make_shared<Out>();
}
};
At that point a Visitor pattern would swap the objects around and perform a second virtual call from other_ to get the second dynamic dispatch. However, as mentioned above, we know exactly what type we're looking for, so we can just dynamic_cast to reach it.
Now we can implement Wrapper::connect as simply:
template < typename A, typename B > void connect (A a, B b)
{
a.get()->connectTo(*b.get());
}
... and define child classes this way:
class Child_1 : public Child<int, float> {
public:
void run() { std::cout<<"running child 1\n"; *ptr_out = 1.234;};
};
See it live on Wandbox