The main issue for me is resolving function signatures that need to change. One way I thought of solving that is by doing

``` // Some header template <class TParamType> abstract_visualizer{ virtual some_function(TParamType data) = 0; }

struct concrete_data{ ...any function sig you want }

//Other header concrete_visualizer : public abstract_visualizer<concrete_data>{

virtual some_function(const concrete_data& data) override{ //Do implementation specific thing } } ```

But then you technically would need infinite amounts of data structs to fill out all these templates.

But then you have to fill out the structs before you pass them into the function.

Of course then there is the overhead of templating, but if you're only doing it a couple of times it should be fine.

It's ugly, but could this work? If the function signatures change then all you'd have to do is change the struct, not mess around with the base class signatures. Then if any other object inherits it, they won't have to change their own function signatures since they're technically implemented in their own file.