My concept for template class hiding breaks data member inheritance. Why? - c++

Question

I would like to add support for protobuf events to my existing event queue.
I wrote a proof-of-concept (see below), which seemed to work fine at first. Unfortunately, compilation aborts when accessing inherited data members. Accessing inherited function members works just fine. Following classes are declared:
Abstract class SubscriptionHolderBase: This is the interface base class
Abstract class SubscriptionHolderCommon: Is supposed to hold the common members of the following two classes.
Depending on the type of the event to subscribe, the compiler shall automatically choose one of the following classes to instantiate:
Template class SubscriptionHolder, specialized for normal events.
Templace class SubscriptionHolder, spezialized for all other (i.e. protobuf) events.
For some reason, SubscriptionHolder seems to inherit the function member of SubscriptionHolderCommon just fine, but when trying to access the data member _member_var (inherited from the same class), following error message is produced:
error: ‘_member_var’ was not declared in this scope
Can someone explain the reason?
My proof-of-concept code:
When commenting all 3 occurences of _member_var, it is doing just fine.
You can compile and let it run online here.
#include <type_traits>
#include <iostream>
class ProtobufEvent {
};
class Proto2 : public ProtobufEvent {
};
class Event {
public:
virtual ~Event(){};
};
class SubscriptionHolderBase {
public:
virtual bool dispatch(Event* event) = 0;
virtual void handle() = 0;
};
template<typename EventType>
class SubscriptionHolderCommon : public SubscriptionHolderBase {
public:
void handle() {
std::cout << "Member function of unspecialized common base class called." << std::endl;
}
protected:
bool _member_var;
};
template<typename EventType, typename Enable = void>
class SubscriptionHolder;
template<typename EventType>
class SubscriptionHolder<EventType, typename std::enable_if<std::is_convertible<EventType*, ProtobufEvent*>::value>::type> : public SubscriptionHolderCommon<EventType> {
public:
virtual bool dispatch(Event* event);
};
template<typename EventType>
class SubscriptionHolder<EventType, typename std::enable_if<!std::is_convertible<EventType*, ProtobufEvent*>::value>::type> : public SubscriptionHolderCommon<EventType> {
public:
virtual bool dispatch(Event* event);
};
template<typename EventType>
bool SubscriptionHolder<EventType, typename std::enable_if<std::is_convertible<EventType*, ProtobufEvent*>::value>::type>::dispatch(Event* event) {
std::cout << "Member function of specialized class for protobuf event called." << std::endl;
_member_var = true;
return false;
}
template<typename EventType>
bool SubscriptionHolder<EventType, typename std::enable_if<!std::is_convertible<EventType*, ProtobufEvent*>::value>::type>::dispatch(Event* event) {
std::cout << "Member function of specialized class for standard event called." << std::endl;
_member_var = true;
return false;
}
int main() {
Event* e = nullptr;
SubscriptionHolderBase* ptr;
SubscriptionHolder<Event> s_e;
ptr = &s_e;
ptr->handle();
ptr->dispatch(e);
std::cout << std::endl;
SubscriptionHolder<ProtobufEvent> s_p;
ptr = &s_p;
ptr->handle();
ptr->dispatch(e);
std::cout << std::endl;
SubscriptionHolder<Proto2> s_p2;
ptr = &s_p2;
ptr->handle();
ptr->dispatch(e);
std::cout << std::endl;
}