class Base
{
virtual void magic()
{
chant();
wave();
profit();
}

virtual chant(){}
virtual wave(){}
virtual profit(){}
};

Assume there is a derived class, Derived, which overrides only wave(). [we want to use default implementations for all else]
Now, if you are wondering why chant(), wave() and profit() were declared virtual, you cannot customize them unless you declare them as virtual. This is because, once your derived class calls magic(), it calls the Base::magic() [we have not overridden magic() for Derived, we have overridden only wave()]. Then, when it calls wave(), it would have called Base::wave() if it had not been declared virtual. Here, we know that we are using Derived object, but just want to reuse the functionality of Base and we are paying the penalty of virtual due to above mentioned problem. CRTP comes to the rescue in precisely these situation, and you can get rid of _all_ virtual functions. Yes sir, all of them

class Base
{
void algo()
{
this->init();
//some common stuff
this->print();
}

virtual void init() = 0;
virtual void print() = 0;
};

class Derived: public Base
{
//implement the specific functions
};

In this case, CRTP can be used to eliminate the need to declare the two implementation functions as virtual.

This may be considered a lesson in “being aware of what should be virtual” versus “make everything virtual, just in case”…