Is there a better way to return the same string literal from both a static and non-static function?

Question

My c++ is pretty rusty and generics always confuse me anyway, so the combination is not good for my brain, so here is my problem.

I have a set of classes that are all going to look like this:

class MyEvent2 : public Event 
{

    public:
    static constexpr char* CLASS_NAME = "MyEvent2";
    MyEvent2(Object& sender) :  Event(sender)
    {
    }

    virtual ~MyEvent2() {}

    static const char* EventId() {
        return MyEvent2::CLASS_NAME;
    }

    const char* eventId() override {
        return MyEvent2::CLASS_NAME;
    }
};

The classes will be used to register event handlers on an event bus, so I add the handlers like so.

  EventBus::AddHandler<MyEvent>(*this);  
  EventBus::AddHandler<MyEvent2>(*this);  

then I create intances of the events and fire them like this:

MyEvent e1(*this);
MyEvent2 e2(*this);
EventBus::FireEvent(e1);
EventBus::FireEvent(e2);

My question is how do I make this generic? I would like to be able to make some derived "Event" class where I just need to include the one line that really needs to be unique

static constexpr char* CLASS_NAME = "TheClassName";

btw: I know could use typeid to get something like this, but I can't use it on Arduino devices.

and then add unique "Event" specific fields and members.

Here is what I have done so far:

I created a template class (or should it be called a class template?):

template<class T>
class ArduinoEvent : public Event 
{

    public:
    T(Object& sender) :  Event(sender)
    {
    }

    virtual ~T() {}

    static const char* EventId() {
        return T::CLASS_NAME;
    }

    const char* eventId() override {
        return T::CLASS_NAME;
    }
};

But I am not sure how to use this or if this is even the right direction.

Answer 1

You could try with Curiosly Recurring Pattern (CRTP) . It would look something like following :

template <typename  T>
class BaseEvent : public Event {
    public:
        static constexpr const char* id = T::CLASS_NAME;

        constexpr const char* eventId() const {
            return T::CLASS_NAME;
        }
};

The template would then be used to instantiate new event classes as follows:

class MyEvent1 : public BaseEvent<MyEvent1> {
    public:
        static constexpr const char* CLASS_NAME = "MyEvent1";
};

class MyEvent2 : public BaseEvent<MyEvent2> {
    public:
        static constexpr const char* CLASS_NAME = "MyEvent2";
};

You could then use these classes as expected:

int main() {

    MyEvent1 e1;
    cout << e1.eventId() 
         << ", " 
         << MyEvent1::id
         << endl;

    MyEvent2 e2;
    cout << e2.eventId() 
         << ", "
         << MyEvent2::id
         << endl;
    return 0;
}

You can check that eventId() behaves as expected in this online example ). Note that the template BaseEvent needs to inherit from Event if you want to handle all events in a polymorphic way.