📂 CRTP (Curiously Recurring Template Pattern)

🧠 Concept

CRTP is a C++ idiom where a class Derived inherits from a template base class that is instantiated with Derived itself.

class Derived : public Base<Derived> {
    // ...
};

🔍 Intuition:

• Though it looks like recursive inheritance, it's really template instantiation.
• It allows the base class to know and use the interface of the derived class at compile time.

🧬 Syntax & Explanation

class Base {
    // typical base class
};

// CRTP base
template<typename Derived>
class Base {
    void interface() {
        static_cast<Derived*>(this)->implementation();
    }
};

class Derived : public Base<Derived> {
public:
    void implementation() {
        std::cout << "Derived implementation\\\\n";
    }
};

🧱 Break Down

• static_cast<Derived*>(this): Tells compiler to treat this pointer of Base as pointer to Derived.
• Allows calling Derived's implementation inside Base — compile-time dispatch.

🧭 Comparison with Virtual Functions

🧪 Example: Virtual vs CRTP

// Virtual Example
class Animal {
public:
    virtual void speak() { std::cout << "Animal sound\\\\n"; }
};

class Dog : public Animal {
public:
    void speak() override { std::cout << "Bark!\\\\n"; }
};

void make_sound(Animal* a) {
    a->speak(); // Runtime dispatch
}

// CRTP Example

template<typename Derived>
class AnimalBase {
public:
    void speak() {
        static_cast<Derived*>(this)->speak();
    }
};

class Dog : public AnimalBase<Dog> {
public:
    void speak() { std::cout << "Bark!\\\\n"; }
};

void make_sound(Dog* d) {
    d->speak(); // Compile-time dispatch
}

🧠 Concept Clarifiers

• Dispatch: The mechanism by which a call to an overridden function is resolved.
  • Static dispatch: Resolved at compile time (CRTP)
  • Dynamic dispatch: Resolved at runtime using vtables
• vtable: A table of function pointers used in dynamic polymorphism to resolve virtual function calls.
  • Each class with virtual methods has a vtable
  • Each object has a vptr pointing to its class's vtable