C++ Academy · Lektion

CRTP-idiomet

Curiously recurring template pattern

Lektion 1 av 413 steg

CRTP-idiomet är en gratis lektion i C++ Academy på CoddyKit. Detta är lektion 1 av 4. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för C++ Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i C++ Academy innehåller totalt 4 lektioner.

Vad är CRTP

Curiously Recurring Template Pattern (CRTP) är ett C++-idiom där en klass Derived ärver från en basmall som instansieras med Derived självt.

Form: class Derived : public Base<Derived>
Basen känner till sin härledda typ vid kompilering

template <typename T>
class Base {};

class Derived : public Base<Derived> {};

Den centrala mekanismen

Inuti basen kan ni använda static_cast för att konvertera pekaren this till den härledda typen. Eftersom den härledda typen är en mallparameter sker denna konvertering helt vid kompilering, utan kostnad vid körning.

#include <iostream>

template <typename T>
class Base {
public:
    void interface() {
        static_cast<T*>(this)->implementation();
    }
};

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

int main() {
    Derived d;
    d.interface();
    return 0;
}

Varför "Curiously Recurring"

Namnet kommer från den uppenbara paradoxen: basklassen hänvisar till den härledda klassen, som ännu inte är fullständigt definierad när mallbasen skrivs.

Det fungerar eftersom mallar endast instansieras när de används
När instansieringen sker är Derived en komplett typ

En första praktisk användning

CRTP låter en bas tillhandahålla återanvändbar funktionalitet som anropar den härledda klassen. Här tillhandahåller basen en print() som delegerar till den härledda klassens name().

#include <iostream>
#include <string>

template <typename T>
struct Named {
    void print() {
        std::cout << static_cast<T*>(this)->name() << "\n";
    }
};

struct Cat : Named<Cat> {
    std::string name() { return "Cat"; }
};

int main() {
    Cat c;
    c.print();
    return 0;
}

Inga virtuella tabeller

Till skillnad från polymorfism vid körning behöver CRTP varken nyckelordet virtual eller en vtable-pekare i varje objekt. Anropsupplösningen sker helt vid kompilering.

Mindre objekt, eftersom ingen dold vptr behövs
Anrop kan inlineas

Räkna instanser

En klassisk CRTP-tillämpning är en objekträknare. Varje härledd klass får automatiskt sin egen statiska räknare.

#include <iostream>

template <typename T>
struct Counter {
    static inline int count = 0;
    Counter() { ++count; }
    ~Counter() { --count; }
};

struct Widget : Counter<Widget> {};

int main() {
    Widget a, b;
    std::cout << Widget::count << "\n";
    return 0;
}

Varje härledd klass får sitt eget tillstånd

Eftersom Counter<Widget> och Counter<Gadget> är distinkta mallinstansieringar har var och en en oberoende statisk count. Denna åtskillnad är omöjlig med en enda bas som inte är en mall.

#include <iostream>

template <typename T>
struct Counter {
    static inline int count = 0;
    Counter() { ++count; }
};

struct A : Counter<A> {};
struct B : Counter<B> {};

int main() {
    A a1, a2;
    B b1;
    std::cout << A::count << " " << B::count << "\n";
    return 0;
}

static_cast är säkert här

Nedkonverteringen inuti basen är säker endast om varje objekt av typen Base<T> verkligen är en T. CRTP garanterar detta genom sin konstruktion, eftersom T är klassen som ärver.

Instansiera aldrig Base<Wrong> för en orelaterad klass

Jämförelseoperatorer med CRTP

Ni kan skapa en komplett uppsättning jämförelseoperatorer från en enda operator< genom att ärva från en jämförelsehjälpklass.

#include <iostream>

template <typename T>
struct Comparable {
    friend bool operator>(const T& a, const T& b) { return b < a; }
    friend bool operator==(const T& a, const T& b) { return !(a < b) && !(b < a); }
};

struct Num : Comparable<Num> {
    int v;
    Num(int x) : v(x) {}
    friend bool operator<(const Num& a, const Num& b) { return a.v < b.v; }
};

int main() {
    std::cout << (Num(3) > Num(2)) << "\n";
    return 0;
}

Skydd med protected-konstruktor

För att förhindra oavsiktlig felanvändning av basen kan ni ge den en protected-konstruktor, så att endast härledda klasser kan skapa den.

#include <iostream>

template <typename T>
class Base {
protected:
    Base() = default;
public:
    void run() { static_cast<T*>(this)->step(); }
};

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

int main() {
    Job j;
    j.run();
    return 0;
}

CRTP i standardbibliotek

CRTP förekommer i många verkliga C++-bibliotek.

std::enable_shared_from_this<T> använder det
Många matematikbibliotek med uttrycksmallar, till exempel Eigen, bygger på det
Ranges- och iteratorhjälpklasser använder liknande mönster

Att känna igen formen X : Base<X> hjälper er att läsa avancerad kod.

Snabbtest

Testa er förståelse av CRTP-formen.

Besvara frågan i den interaktiva lektionen

Sammanfattning

Ni har lärt er CRTP-idiomet.

Derived : Base<Derived> ger basen dess konkreta typ
En static_cast<T*>(this) möjliggör anropsupplösning vid kompilering
Ingen vtable, mindre objekt och anrop som kan inlineas
Används för räknare, jämförelse-mixins och bibliotekshjälpklasser

Gratis att börja

Lär dig C++ med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 51
Lektioner: 203

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”CRTP-idiomet” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen C++ Academy, inklusive ”CRTP-idiomet”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i C++ Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”CRTP-idiomet”?

Curiously recurring template pattern Ni övar på C++ Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig C++ Academy?

Du behöver inga förkunskaper. Utbildningen i C++ Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.

Hur lång tid tar lektionen ”CRTP-idiomet”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här C++ Academy-lektionen?

Ja. Varje C++ Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till C++ Academy