abstract classes and templates - c++

Question

I do have some general data type and some derived type(s):
class abstract_data { virtual void foo() {}; };
class derived_data : public abstract_data { void foo() {} };
I want to write some classes that work on that data. What I would like to do is:
class abstract_worker {
public:
virtual void apply(abstract_data&) = 0;
};
class derived_worker : public abstract_worker {
public:
void apply(derived_data&) {} ;
};
This is not working, because the compiler asks me to implement void apply(abstract_data&). I see two alternatives.
1.alternative:
class abstract_worker {
public:
virtual void apply(abstract_data&) = 0;
};
class derived_worker : public abstract_worker {
public:
void apply(abstract_data& data) {
derived_data& internal_data = dynamic_cast<derived_data&>(data);
}
};
2. alternative:
template<class DATA_TYPE>
class abstract_worker {
public:
virtual void apply(DATA_TYPE&) = 0;
};
class derived_worker : public abstract_worker<derived_data> {
public:
void apply(derived_data&) { }
};
I don't like both of them. In the 1st alternative the parameter is declared as abstract_data& even though it really needs to be derived_data&.
In the 2nd alternative it gets lost that the parameter is of type abstract_data&. This is even more problematic if apply(abstract_data&) is not pure virtual, but uses some functionality of abstract_data. You run in the situtation where abstract_data& is implicitely required as DATA_TYPE, but not explicitely declared as such.
However, I do want to keep the type relationships.
Is there another way? If not which one would you prefer?

Answer 1

You might use static assert to prevent DATA_TYPE not inheriting from abstract_data:
#include
class abstract_data { virtual void foo() {}; };
class derived_data : public abstract_data { void foo() {} };
class faulty_data { void foo() {} };
template<class DATA_TYPE>
class abstract_worker {
static_assert(std::is_base_of<abstract_data, DATA_TYPE>::value, "DATA_TYPE does not inherit from abstract_data");
public:
virtual void apply(DATA_TYPE&) = 0;
};
class derived_worker : public abstract_worker<derived_data> {
public:
void apply(derived_data&) {}
};
class faulty_worker : public abstract_worker<faulty_data> {
public:
void apply(faulty_data&) {}
};
Output while compiling:
1>------ Build started: Project: Test_Call, Configuration: Debug Win32 ------
1> Source.cpp
1><PROJ_PATH>\source.cpp(9): error C2338: DATA_TYPE does not inherit from abstract_data
1> <PROJ_PATH>\source.cpp(20): note: see reference to class template instantiation 'abstract_worker<faulty_data>' being compiled
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========