Augmenting functionality of subclasses without code duplication in C++

Question

I have to add common functionality to some classes that share the same superclass, preferably without bloating the superclass. The simplified inheritance chain looks like this:

Element -> HTMLElement -> HTMLAnchorElement
Element -> SVGElement -> SVGAlement

The default doSomething() method on Element is no-op by default, but there are some subclasses that need an actual implementation that requires some extra overridden methods and instance members. I cannot put a full implementation of doSomething() in Element because 1) it is only relevant for some of the subclasses, 2) its implementation has a performance impact and 3) it depends on a method that could be overridden by a class in the inheritance chain between the superclass and a subclass, e.g. SVGElement in my example.

Especially because of the third point, I wanted to solve the problem using a template class, as follows (it is a kind of decorator for classes):

struct Element {
 virtual void doSomething() {}
};
// T should be an instance of Element
template<class T>
struct AugmentedElement : public T {
 // doSomething is expensive and uses T
 virtual void doSomething() override {}
 // Used by doSomething
 virtual bool shouldDoSomething() = 0;
};
class SVGElement : public Element { /* ... */ };
class SVGAElement : public AugmentedElement<SVGElement> {
 // some non-trivial check
 bool shouldDoSomething() { /* ... */ return true; }
};
// Similarly for HTMLAElement and others

I looked around (in the existing (huge) codebase and on the internet), but didn't find any similar code snippets, let alone an evaluation of the effectiveness and pitfalls of this approach.

Is my design the right way to go, or is there a better way to add common functionality to some subclasses of a given superclass?

Answer 1

You are doing it correctly. The thing is called a mixin and is rather common.

Quick search shows e.g. What are Mixins (as a concept) or What is C++ Mixin-Style?. They are a case of the Curiously Recurring Template Pattern, name of which even comes from the fact that it is, well, recurring.

In your case actually using full CRTP would let you avoid the virtual:

template<typename BaseT, typename DerivedT>
struct AugmentedElement : public BaseT {
 // doSomething is expensive and uses T
 virtual void doSomething() override {
 // do stuff
 static_cast<DerivedT *>(this)->shouldDoSomething();
 // do more stuff, etc.
 }
};

• Rob W: I thought that a mixin was an extension to a superclass rather than an override. Is that incorrect? Thanks for mentioning CRTP, I left it out of the question because I thought that it was not relevant, but with your example the name seems to make more sense. PS. "T" should be changed to "BaseT" in your example.
• Jan Hudec: @RobW: Mixin is any template that you inject into the inheritance chain.