Template type of class in inheritance - c++

Question

Let's say I have class Action
template<class T>
class Action {
public:
virtual ~Action() = default;
virtual void execute(T &object) const = 0;
};
which can be executed on some object of type T
Next, I have class Object
class Object {
public:
Object() : actions() {}
virtual ~Object() = default;
virtual const std::string getName() const = 0;
void addAction(const Action<Object> *action) {
actions.push_back(action);
}
void execute() {
for (auto &action : actions) {
action->execute(*this);
}
}
private:
std::vector<const Action<Object> *> actions;
};
which holds a vector of actions which can be executed at once.
Now, I have some concrete ObjectA
class ObjectA : public Object {
public:
const std::string getName() const override {
return "ObjectA";
}
};
and two concrete actions ActionA, ActionB
class ActionA : public Action<ObjectA> {
void execute(ObjectA &object) const override {
std::cout << "ActionA on " << object.getName() << std::endl;
}
};
class ActionB : public Action<ObjectA> {
void execute(ObjectA &object) const override {
std::cout << "ActionB on " << object.getName() << std::endl;
}
};
The usage is that I create an ObjectA, add both action to it and execute them.
int main() {
ObjectA object = ObjectA{};
object.addAction(reinterpret_cast<const Action<Object> *>(new ActionA()));
object.addAction(reinterpret_cast<const Action<Object> *>(new ActionB()));
// This is what I want to achieve instead of using reinterpret_cast
//object.addAction(new ActionA());
//object.addAction(new ActionB());
object.execute();
}
The output should be
ActionA on ObjectA
ActionB on ObjectA
The problem is that in order to compile it, I must use reinterpret_cast. The problem is probably the definition of std::vector<const Action<Object> *> actions; I would like to template this, so in ObjectA it is like std::vector<const Action<ObjectA> *> actions;
Is something like that possible?

Answer 1

Action<Object> and Action<ObjectA> are unrelated types in the C++ type system.
What more, Action<Object> permits itself to be called with more types than Action<ObjectA>. So ignoring the type system, an Action<ObjectA> cannot implement the contract that Action<Object> promises it can fulfill.
However, an Action<Object> can fulfill the promise that an Action<ObjectA> makes.
There are famous two kinds of OO-type relations; covariance and contravariance. Action<T> is cotravariant in T, Action<Base> can be used to fulfill the contract of Action<Derived>.
So an approach.
First, your Action<T> is a poorly written pointer-semantic version of std::function<void(T&)>. Use that instead.
You now have value semantics.
template<class T>
using Action=std::function<void(T&)>;
class Object {
public:
Object() = default;
virtual ~Object() = default;
virtual const std::string getName() const = 0;
void addAction(Action<Object> action) {
actions.emplace_back(std::move(action));
}
void execute() {
for (auto &action : actions) {
action(*this);
}
}
private:
std::vector<Action<Object>> actions;
};
ah, much nicer.
This doesn't, however, solve your problem.
auto ActionA = Action<ObjectA>{
[](ObjectA &object) {
std::cout << "ActionA on " << object.getName() << std::endl;
}
};
ActionA cannot be assigned to an Action<Object> because an Action<Object> can be passed a non-ObjectA and it must do something with it.
Your original code's override won't compile.
We have to decide if we want to pretend to be an Action<Object> what we should do if the types mismatch? Here is one option:
template<class T, class F>
auto only_when_dynamic_type_matches( F&& f ) {
if constexpr( std::is_pointer< T >{} ) {
return
[f=std::forward<F>(f)](auto* x)->void{
auto* t = dynamic_cast<T>(x);
if (!t) return
f(t);
};
} else {
return
[f=std::forward<F>(f)](auto&& x)->void{
auto* t = dynamic_cast<std::remove_reference_t<T>*>(std::addressof(x));
if (!t) return;
f(*t);
};
}
}
now we can write
auto ActionA = only_when_dynamic_type_matches<ObjectA&>([](auto&&object) {
std::cout << "ActionA on " << object.getName() << std::endl;
});
auto ActionB = only_when_dynamic_type_matches<ObjectA&>([](auto&&object) {
std::cout << "ActionB on " << object.getName() << std::endl;
});
then
int main() {
ObjectA object = ObjectA{};
object.addAction(ActionA);
object.addAction(ActionB);
object.execute();
}
Live example.