PricingLoginStart free
C++ Academy · Les

Statische polymorfie

Vermijd overhead van virtuele aanroepen

Les 2 van 413 stappen

Statische polymorfie is een gratis C++ Academy-les op CoddyKit. Dit is les 2 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject C++ Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus C++ Academy bevat in totaal 4 lessen.

Twee soorten polymorfisme

C++ ondersteunt twee vormen van polymorfisme.

  • Dynamisch: virtuele functies worden tijdens runtime via een vtable opgelost
  • Statisch: templates en CRTP worden tijdens het compileren opgelost

Statisch polymorfisme ruilt flexibiliteit in voor snelheid.

De kosten van virtual

Een virtuele aanroep vereist een indirecte sprong via de vtable. De compiler kan deze meestal niet inlinen, waardoor veel optimalisaties worden verhinderd.

#include <iostream>

struct Shape {
    virtual double area() const = 0;
    virtual ~Shape() = default;
};

struct Square : Shape {
    double s;
    Square(double x) : s(x) {}
    double area() const override { return s * s; }
};

int main() {
    Shape* p = new Square(3);
    std::cout << p->area() << "\n";
    delete p;
    return 0;
}

Statische dispatch met CRTP

Met CRTP roept de basisklasse de methode van de afgeleide klasse rechtstreeks aan via een cast tijdens het compileren, zodat de compiler alles kan inlinen.

#include <iostream>

template <typename T>
struct Shape {
    double area() const { return static_cast<const T*>(this)->area(); }
};

struct Square : Shape<Square> {
    double s;
    Square(double x) : s(x) {}
    double area() const { return s * s; }
};

int main() {
    Square sq(3);
    std::cout << sq.area() << "\n";
    return 0;
}

Naamgeving van doorgeefmethoden

Wanneer de basis- en afgeleide klasse beide area definiëren, geef je de doorgeefmethode van de basisklasse een andere naam, zoals compute, zodat deze ondubbelzinnig de implementatie van de afgeleide klasse aanroept.

#include <iostream>

template <typename T>
struct Shape {
    double compute() const { return static_cast<const T*>(this)->area(); }
};

struct Circle : Shape<Circle> {
    double r;
    Circle(double x) : r(x) {}
    double area() const { return 3.14159 * r * r; }
};

int main() {
    Circle c(2);
    std::cout << c.compute() << "\n";
    return 0;
}

Templates als statisch polymorfisme

Gewone functietemplates zijn ook statisch polymorfisme: dezelfde code werkt voor elk type dat de vereiste interface biedt (duck typing tijdens het compileren).

#include <iostream>

struct Dog { void speak() const { std::cout << "Woof\n"; } };
struct Cat { void speak() const { std::cout << "Meow\n"; } };

template <typename Animal>
void make_speak(const Animal& a) { a.speak(); }

int main() {
    make_speak(Dog{});
    make_speak(Cat{});
    return 0;
}

Wanneer het type bekend is

Statische polymorfie werkt alleen wanneer het concrete type tijdens de compilatie bekend is. Als je heterogene objecten in één container moet opslaan en het gedrag tijdens de uitvoering moet kiezen, heb je nog steeds virtuele functies nodig.

Geen heterogene containers

Je kunt Shape<Square> en Shape<Circle> niet als een gemeenschappelijke basisklasse in dezelfde std::vector plaatsen, omdat het ongerelateerde types zijn. Dit is de belangrijkste beperking van statische polymorfie.

Prestatievoordeel

Door de aangeroepen functie inline te plaatsen, kan de compiler constanten vouwen en de overhead van functieaanroepen volledig elimineren. In krappe lussen over één bekend type kan statische polymorfie aanzienlijk sneller zijn.

#include <iostream>

template <typename T>
struct Op {
    int apply(int x) const { return static_cast<const T*>(this)->apply(x); }
};

struct Doubler : Op<Doubler> {
    int apply(int x) const { return x * 2; }
};

int main() {
    Doubler d;
    int sum = 0;
    for (int i = 0; i < 5; ++i) sum += d.apply(i);
    std::cout << sum << "\n";
    return 0;
}

Beide combineren

Je kunt CRTP gebruiken voor het prestatiekritieke pad en een dunne virtuele omhulling wanneer type-erasure nodig is. Zo krijg je snelheid waar die telt en flexibiliteit waar die nodig is.

Statische interfacecontroles

Als een afgeleide klasse vergeet de vereiste methode te implementeren, verschijnt de fout tijdens de compilatie wanneer de doorgeefmethode van de basisklasse wordt geïnstantieerd, niet tijdens de uitvoering.

#include <iostream>

template <typename T>
struct Greeter {
    void greet() const { static_cast<const T*>(this)->hello(); }
};

struct English : Greeter<English> {
    void hello() const { std::cout << "Hello\n"; }
};

int main() {
    English{}.greet();
    return 0;
}

Het juiste hulpmiddel kiezen

Gebruik statische polymorfie wanneer:

  • het type tijdens de compilatie bekend is
  • prestaties cruciaal zijn
  • je geen gemeenschappelijk basistype tijdens de uitvoering nodig hebt

Gebruik anders bij voorkeur virtuele functies voor duidelijkheid en flexibiliteit.

Korte controle

Kies de belangrijkste afweging van statische polymorfie.

Beantwoord dit in de interactieve les

Samenvatting

Je hebt statische en dynamische polymorfie vergeleken.

  • Virtueel = dispatch tijdens de uitvoering, vtable, heterogene containers
  • CRTP/templates = dispatch tijdens de compilatie, inline te plaatsen, sneller
  • Statische polymorfie vereist dat het type tijdens de compilatie bekend is
  • Maak je keuze op basis van de behoefte aan flexibiliteit of prestaties
Gratis beginnen

Leer C++ met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen
51
Lessen
203
Gratis beginnen met lerenBekijk de volledige cursus

Veelgestelde vragen

Is de les “Statische polymorfie” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad C++ Academy, waaronder “Statische polymorfie”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus C++ Academy bevat in totaal 4 lessen.

Wat leer ik in “Statische polymorfie”?

Vermijd overhead van virtuele aanroepen Je oefent met C++ Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met C++ Academy te beginnen?

Ervaring vooraf is niet nodig. C++ Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 2 van 4.

Hoe lang duurt de les “Statische polymorfie”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over C++ Academy?

Ja. Elke les over C++ Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

  1. Het CRTP-idioom
  2. Statische polymorfie
  3. Mixins met CRTP
  4. Wanneer gebruikt u CRTP
← Terug naar C++ Academy