cache a Base type from template function to use in std::is_base_of

Question

I want to create a library that :-

User adds callback via addCallback<Base>(Callback* callback) (usually at first timestep)
Later, usually in a different .cpp, whenever user call actor<Bx>() :-
- if Bx inherit from Base, call callback->callback()
- else do nothing
(Information) I know for sure that every Bx always inherit from A.

Here is the initial code :-

#include <iostream>
class A{};
class Callback{
     public: virtual void callback()=0; 
};
template<class Base> void addCallback(Callback* callback){  
    //???
};
template<class Bx> void actor(){
    //???
}
//^^^^^^ my library end here

class B : public A{};
class B1 : public B{};
class C : public A{};
class CallbackCustom1: public Callback{
    public: virtual void callback(){std::cout<<"A"<<std::endl;}
};
class CallbackCustom2: public Callback{
    public: virtual void callback(){std::cout<<"B"<<std::endl;}
};
int main(){
    CallbackCustom1 call1;
    CallbackCustom2 call2;
    addCallback<A>(&call1); 
    addCallback<B>(&call2); 
    //vvv  below is usually in another .cpp
    actor<B1>(); // should print "A" and "B"
    actor<C>(); // should print "A" only
}

How to do it?

My poor solutions

Solution 1 : std::is_base_of

I really love to use std::is_base_of<Base,Derive>.
However, it is impossible because users want to invoke only a single type Bx in actor<Bx>() for convenience.
std::is_base_of need name of two classes not one.

Solution 2 (MCVE demo) : virtual destructor + std::function

It can be optimized more but I want to keep it simple :-

#include <iostream>
#include <functional>
class A{public: virtual ~A()=default; };
class Callback{
     public: virtual void callback()=0; 
};
class MyTuple{public:
    std::function<bool(A*)> func;
    Callback* callback;
};
std::vector<MyTuple> myTuples;
template<class Base> void addCallback(Callback* callback){  
    std::function<bool(A*)> func=
        [](A* a){return dynamic_cast<Base*>(a)!=nullptr;};
    MyTuple tuple; tuple.func=func; tuple.callback=callback;
    myTuples.push_back(tuple);
}
template<class Bx> void actor(){
    Bx b;
    for(auto tuple:myTuples){
        if(tuple.func(&b)){
            tuple.callback->callback();
        }
    }
}
//^^^^^^ my library end here

It works, but there are some disadvantages :-

I have to add virtual destructor to A to make it polymorphic. I feel that it is a nasty hack.
In my game, in some time-steps, A::~A() is potentially called >100,000 times per seconds.
I can reduce the cost by make B1 and C final and do a batch deletion via derived class, but in some places, it is unsuitable and inconvenient.
I have to create instance of Bx just for the dynamic_cast check.
This may cause some complication if its constructor do something special.

Are there any better way?

An even worse hack comes to mind: `throw` and `catch` could be abused to test for a public inheritance relationship between non-polymorphic classes at runtime. If you do dare to play with that, you can use some `std::type_index` to cache results and make sure that step is only done once per new type encountered. — aschepler, Jan 23 '19 at 05:47
@aschepler like [Cassio Neri's solution](https://stackoverflow.com/a/18100934) in https://stackoverflow.com/questions/18099241/check-if-class-is-derived-from-a-specific-class-compile-runtime-both-answers-a ? — cppBeginner, Jan 23 '19 at 05:53
A similar idea, yes, but for your use case, the `throw` and `catch` would need to be in different functions. — aschepler, Jan 23 '19 at 06:18

Julius · Answer 1 · 2019-01-25T13:30:28.150

Can you require your user to specify the set of allowed Base types? In that case the task becomes simple (online demo):

static_assert(__cplusplus >= 201703L, "example for C++17, but C++14 possible");

#include <iostream>
#include <type_traits>
#include <vector>

struct Callback {
  virtual void callback() = 0;
};

template<class... RegisteredBases>
struct CallbackSystem {

  template<class Base>
  static auto& callbacks_for() {
    static std::vector<Callback*> callbacks_for_base_{};
//
// For each `Base`, the callbacks are stored in a different vector.
// This way, we can avoid the in-loop branch (see `actor_impl`).
//
// TODO: consider performance cost of bad memory locality (can be
// improved if necessary).
//
    return callbacks_for_base_;
  }

  template<class Base>
  static void addCallback(Callback* callback) {
    static_assert((... || std::is_same<Base, RegisteredBases>{}));
    callbacks_for<Base>().push_back(callback);
  }

  template<class Derived, class RegisteredBase>
  static void actor_impl() {// called from `actor` for each RegisteredBase
    if(std::is_base_of<RegisteredBase, Derived>{}) {// branch outside loop
      // if `RegisteredBase` matches then process all its callbacks
      for(Callback* callback : callbacks_for<RegisteredBase>()) {
        callback->callback();
      }
    }
  }

  template<class Derived>
  static void actor() {
    (actor_impl<Derived, RegisteredBases>(), ...);
  }
};

The allowed Base types are registered like this:

using MyCallbacks = CallbackSystem<A, B> {};

The usage reads:

MyCallbacks::addCallback<A>(&call1);
MyCallbacks::addCallback<B>(&call2);
// MyCallbacks::addCallback<B1>(&call2);// compile error (good)


//vvv  below is usually in another .cpp
std::cout << R"(should print "A" and "B":)" << std::endl;
MyCallbacks::actor<B1>();

std::cout << R"(should print "A" only:)" << std::endl;
MyCallbacks::actor<C>();

Alternatively, the API can be designed the other way around: Instead of restricting the Base classes one can require the user to specify all classes which are allowed as the template argument of actor.

I stare at the code for a while. It is hard to test, may you provide some MVCE (e.g. http://coliru.stacked-crooked.com/) ? It looks useful. Thanks. — cppBeginner, Jan 25 '19 at 10:18
@cppBeginner: Added link to online demo (see first paragraph of my answer). The singleton-style is probably bad design, but the idea of constrained types can also be applied to a non-singleton: `CallbackSystem callbacks{}; callbacks.add_callback (&call1); /* ... pass instance around (by reference)... */ callbacks.actor();` — Julius, Jan 25 '19 at 13:42
In the the first version of your answer (I prefer), users have to do an extra typing. It is a little error prone and less maintainable. (It is cleaner and better than CRTP, though.) In this version, users have to use the *correct* callback to call actor e.g. `CallbackSystem::actor()`. Despite `MyCallbacks` alias, usefulness of callback is reduced. By the way, I use singleton for simplicity of MCVE. I don't actually use the pattern. Thank. :) — cppBeginner, Jan 26 '19 at 02:05
@cppBeginner: Yes, I agree that the suggestion in my [original answer](https://stackoverflow.com/revisions/54337896/1) (where the user had to specify the bases of each class) is error prone. In addition, some level of metaprogramming is required in order to collect those user-provided information. I also agree that the current version is fragile if `CallbackSystem::actor()` is used instead of `MyCallbacks::actor();`. Note that this is not an issue if the callbacks are handled in non-singleton instances: `void do_stuff(MyCallbacks& callbacks) { actor(callbacks); }`. — Julius, Jan 26 '19 at 11:12

cache a Base type from template function to use in std::is_base_of

My poor solutions

Solution 1 : std::is_base_of

Solution 2 (MCVE demo) : virtual destructor + std::function

1 Answers1