zurück zum Artikel

Dieser Beitrag fasst die wichtigsten Fakten zu den in C++ häufig verwendeten Idiomen für Polymorphismus und Templates zusammen.

In meiner Artikelserie zu Idiomen in C++ nimmt dieser Beitrag eine Sonderrolle ein, denn ich habe in der jüngeren Vergangenheit bereits an verschiedenen Stellen über Polymorphie und Templates geschrieben. Nun möchte ich aber nochmals die wichtigsten Fakten zu diesen in C++ häufig verwendeten Idiomen zusammenfassen. Um mich dennoch nicht unnötig zu wiederholen, beschränke ich an dieser Stelle darauf, eine kurze Beschreibung des Themas zu präsentieren und auf die ausführlicheren Texte zu verweisen.

Die Idiome für Polymorphismus und Templates spielen in C++ generell eine wichtige Rolle. Beide kommen daher auch häufig zum Einsatz.

Polymorphie

Polymorphie ist die Eigenschaft, die dafür sorgt, dass verschiedene Typen die gleiche Schnittstelle unterstützen können. In C++ wird zwischen dynamischer und statischer Polymorphie unterschieden.

Dynamische Polymorphie

Dynamischer Polymorphismus findet zur Laufzeit statt, er basiert auf der Objektorientierung und ermöglicht die Trennung zwischen der Schnittstelle und der Implementierung einer Klassenhierarchie. Um Late Binding, Dynamic Dispatch oder Dispatch zur Laufzeit zu erreichen, braucht man zwei Zutaten: Virtualität und eine Indirektion wie einen Zeiger oder eine Referenz.

• Statische und dynamische Polymorphie [1]

Curiously Recurring Template Pattern (CRTP)

Der Kerngedanke von CRTP ist einfach: Eine Klasse Derived leitet sich von einem Klassen-Template Base ab und Base hat Derived als Template-Argument.

template <typename T>
class Base {
    ...
};

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

• Mehr Details zur statischen und dynamischen Polymorphie [2]

Statische Polymorphie

Die statische Polymorphie basiert auf CRTP. Statische Polymorphie erfolgt zur Kompilierzeit und besitzt keine Laufzeitkosten.

Das Overload Pattern

Typischerweise kommt das Overload Pattern für eine std::variant [3] zum Einsatz. std::variant ist eine typsichere Union, die einen Wert aus einem ihrer Typen besitzt. std::visit [4] erlaubt es, einen Besucher darauf anzuwenden. Genau hier kommt das Overload Pattern in C++20 sehr praktisch ins Spiel.

template<typename ... Ts> 
struct Overload : Ts ... { 
    using Ts::operator() ... ; 
};

• Clevere Tricks zu Parameterpacks und Fold Expressions [5]
• Eine std::variant mit dem Overload Pattern besuchen [6]

Templates

Templates erweitern C++ um viele neue Idiome.

Mixins

Mixins sind eine beliebte Idee beim Entwurf von Klassen, um einen neuen Code hinzuzumischen. Mixins lassen sich in C++ mithilfe von CRTP implementieren. Ein bekanntes Beispiel ist die Klasse std::enable_shared_from_this [7].

• Mixins und das CRTP [8]

Expression Templates

Expression Templates werden typischerweise in der linearen Algebra verwendet und sind "structures representing a computation at compile-time, which structures are evaluated only as needed to produce efficient code for the entire computation" [9]. Mit anderen Worten: Expression Templates werden nur bei Bedarf ausgewertet.

Temporäre Objekt mit Expression Templates vermeiden [10]

Policy

Eine Policy ist eine generische Funktion oder Klasse, deren Verhalten konfiguriert werden kann. Typischerweise gibt es Standardwerte für die Policy-Parameter. std::vector und std::unordered_map sind Beispiele für diese Design-Idee in der Standard Template Library.

template<class T, class Allocator std::allocator<T>>        
class vector; 

template<class Key,
    class T,
    class Hash = std::hash<Key>,                               
    class KeyEqual = std::equal_to<Key>,                       
    class allocator = std::allocator<std::pair<const Key, T>>  
class unordered_map

• Softwaredesign mit Policies [11]

Traits

Traits sind Klassen-Templates, die Merkmale eines generischen Typs bereitstellen. Sie können ein oder mehrere Merkmale eines Klassen-Templates extrahieren.

• Softwareentwurf mit Traits und Tag-Dispatching [12]

Tag-Dispatching

Tag-Dispatching ist eine Methode zur Simulation von Funktionsüberladung auf der Grundlage von Konzepten, die häufig auf Traits basieren.

• Eine std::advance Implementierung mit C++98, C++17 und C++20 [13]

Type Erasure

Type Erasure ermöglicht es, verschiedene konkrete Typen mit einer generischen Schnittstelle zu verwenden. In C basiert sie auf void-Zeigern, in C++ auf der Objektorientierung oder auf Templates.

• Type Erasure [14]

Wie geht's weiter?

In meinem nächsten Artikel habe ich die Freude, einen Gastbeitrag von Alex Eisenhut [15] präsentieren zu dürfen. Alex wird über seine Leidenschaft berichten: "gute" Softwarearchitektur.

(map [23])

URL dieses Artikels:
https://www.heise.de/-7534581

Links in diesem Artikel:
[1] https://www.heise.de/blog/Statische-und-dynamische-Polymorphie-6498701.html
[2] https://www.heise.de/blog/Mehr-Details-zur-statischen-und-dynamischen-Polymorphie-6526677.html
[3] https://en.cppreference.com/w/cpp/utility/variant
[4] https://en.cppreference.com/w/cpp/utility/variant/visit
[5] https://www.heise.de/blog/Clevere-Tricks-mit-Parameterpacks-und-Fold-Expressions-6195143.html
[6] https://www.heise.de/blog/Eine-std-variant-mit-dem-Overload-Pattern-besuchen-6200578.html
[7] https://en.cppreference.com/w/cpp/memory/enable_shared_from_this
[8] https://www.heise.de/blog/Mixins-6535761.html
[9] https://en.wikipedia.org/wiki/Expression_templates
[10] https://www.heise.de/blog/Temporaere-Objekte-vermeiden-mit-Expression-Templates-6546908.html
[11] https://www.heise.de/blog/Softwaredesign-mit-Policies-6587002.html
[12] https://www.heise.de/blog/Softwaredesign-mit-Traits-und-Tag-Dispatching-6599217.html
[13] https://www.heise.de/blog/Eine-std-advance-Implementierung-mit-C-98-C-17-und-C-20-6659635.html
[14] https://www.heise.de/blog/Type-Erasure-6667495.html
[15] https://www.eisenhuth-se.de/ueber-mich/
[16] https://www.modernescpp.org/fundamentals-for-c-professionals/
[17] https://www.modernescpp.org/design-patterns-and-architectural-patterns-with-c/
[18] https://dashboard.mailerlite.com/forms/241414/73224903163119423/share
[19] https://www.modernescpp.de/index.php/c/2-c/42-c-2020220806075004
[20] https://www.modernescpp.de/index.php/c/2-c/44-clean-code-best-practices-fuer-modernes-c20221017070010
[21] https://www.modernescpp.de/index.php/c/2-c/43-design-pattern-und-architekturpattern-mit-c20220806075117
[22] https://www.modernescpp.de/index.php/c/2-c/46-embedded-programmierung-mit-modernem-c20230204145614
[23] mailto:map@ix.de

Copyright © 2023 Heise Medien