Bad Example:

class Geometry {
    virtual void thingy() = 0;
}

class Circle : public Geometry() {
    void thingy() override;
}

class Square : public Geometry() {
    void thingy() override;
}

void do_something(Geometry *object) {
    object->thingy();
}

This will create a VTable, a vtable will always do a second jmp instruction when you call the function, as it does not know what function to call, it needs to inspect the virtual table call and then call the correct function.

This on the other hand will always call the function correctly without an extra call, and the size of the structures will be smaler, as there will not be a VTable

template<typename T>
thingy(T Geometry) {

}

template<Circle>
thingy(Circle& circle) {

}

Template<Square>
thingy(Square& circle) {

}

template<typename T> do_something(T object) {
    thingy<T>(object);
}