CRTP with pure abstract base class : call overhead - c++

Question

I am using CRTP for some classes. However, I need to homogeneously store these classes for example in an std::vector.
A solution would be to have a common abstract base class. For example, as explained in the wikipedia page on CRTP :
// Base class has a pure virtual function for cloning
class Shape {
public:
virtual ~Shape() {};
virtual void draw() = 0;
};
// This CRTP class implements clone() for Derived
template <typename Derived>
class Shape_CRTP : public Shape {
public:
void draw() {
static_cast<Derived const&>(*this)->draw();
}
};
class Square: public Shape_CRTP<Square> {
void draw() {/// implement draw}
};
class Circle: public Shape_CRTP<Circle> {
void draw() {/// implement draw}
};
and in the main :
std::vector<Shape*> shapes;
for (auto s : shapes) {
s->draw();
}
But in this case, don't I lose the benefits of static polymorphism as I will have the virtual call overhead (draw is virtual in the common base class), and as my draw implementations will not be inlined?
Please explain and point me to references if you have some

Answer 1

First and most important, let's state the reason for CRTP: it is a tool for code reduction. The corresponding base class is hardly ever used by itself, but rather to implement functions which are shared by several derived classes (and which you'd otherwise would have to retype in any derived class anew).
In CRTP, it is good style to separate the "pure virtual functions", which are to be implemented in the derived class, via their name. I usually use the suffix _impl for that and put the functions in protected scope. This directly tells you which of the functions in the CRTP base class one should implement in derived classes (whereas the others would work out of the box).
Applied to your example this would look like the following:
struct Shape {
virtual ~Shape() {};
virtual void draw() const = 0;
};
template <typename Derived>
struct Shape_CRTP : public Shape {
protected:
void draw_impl() const = delete;
public:
virtual void draw() const override final {
static_cast<Derived const&>(*this).draw_impl();
}
};
struct Square: public Shape_CRTP<Square> {
friend Shape_CRTP<Square>;
protected:
void draw_impl() const {/* implement draw */}
};
struct Circle: public Shape_CRTP<Circle> {
friend Shape_CRTP<Circle>;
protected:
void draw_impl() const {/* implement draw */}
};
Let's look at this from the perspective of performance:
When you work with a pointer to the virtual base class Shape, the previous solution is equivalent to yours. In both cases you have a dynamic access via a vtable, and this has the same overhead regardless of the dept of the inheritance hierarchy (i.e. regardless whether you point to Square as in your solution or to Shape_CRTP<Square> as in mine).
When you work directly with the derived class Square, it's also equivalent, because then the compiler can call the draw() function directly (either via the derived class in your solution or via the CRTP base in mine).
And, as said, one hardly ever works with Shape_CRTP directly, so there is also no point in analysing its behavior.
Summarizing, CRTP has no effect on the runtime performance here. So, why you should need CRTP at all? Again, for code reduction! An this pays out the most, if you have
either only a few _impl() functions to derive from, and a whole lot of functions in the CRTP base class, or
a lot of different derived classes, where saving a few function implementations could be worth it.
Depending on the actual problem, CRTP can save thousands lines of code, and in general, it's a great tool exactly for that.