{"id":4952,"date":"2025-09-01T14:02:33","date_gmt":"2025-09-01T12:02:33","guid":{"rendered":"https:\/\/fliegerhorst.dyndns.org\/?p=4952"},"modified":"2026-03-02T15:34:41","modified_gmt":"2026-03-02T14:34:41","slug":"c","status":"publish","type":"post","link":"https:\/\/fliegerhorst.dyndns.org\/index.php\/2025\/09\/01\/c\/","title":{"rendered":"C++"},"content":{"rendered":"\n

Ich habe mir das Buch „Eine Tour durch C++“<\/strong> (2023) von Bjarne Stroustrup<\/em> gekauft und werde hier ein paar Extrakte aus dem Buch als Nachschlagewerk zusammenstellen, um die leicht auffindbar zu haben.<\/p>\n\n\n\n

Referenz<\/h3>\n\n\n\n

Als gutes Nachschlagewerk hat sich die folgende Internetseite etabliert: CPLUSPLUS.COM<\/a>. Insbesondere ist hier die Standard Template Library sehr gut beschrieben und wird hier auch immer aktuell gehalten.<\/p>\n\n\n\n

Ein gutes Tutorial, bei dem es auch zu jedem Beitrag ein Beispiel gibt, ist hier <\/a>zu finden. Hier<\/a> ist ein weiteres Tutorial, was von der Machart ziemlich dasselbe ist wie das vorige.<\/p>\n\n\n\n

Neue Schl\u00fcsselw\u00f6rter und deren Bedeutung<\/h3>\n\n\n\n
Kategorie<\/th>Schl\u00fcsselwort<\/th>Erl\u00e4uterung<\/th><\/tr><\/thead>
Konstanten<\/td>const<\/code><\/td>Konstante, die zur Laufzeit zugewiesen werden kann. Muss nicht bereits zur Compile-Zeit feststehen.<\/td><\/tr>
Konstanten<\/td>constexpr<\/code><\/td>NEU !! Diese Konstante mu\u00df bereits beim Kompilieren feststehen Sie kann nicht erst zur Laufzeit berechnet werden.<\/td><\/tr>
Konstanten<\/td>constexpr<\/code><\/td>NEU !! Wenn der return-Wert einer Funktion einer const<\/code>-Konstante zugewiesen werden soll.
Beispiel: constexpr u32 Funktionsname(...) {...}<\/code><\/td><\/tr>
Konstanten<\/td>consteval<\/code><\/td>NEU !! Wenn der return-Wert einer Funktion einer constexpr<\/code> Konstante zugewiesen werden soll, also bereits zur Compile-Zeit feststehen mu\u00df.
Beispiel: consteval u32 Funktionsname(...) {...}<\/code><\/td><\/tr>
Deklaration<\/td>auto<\/code><\/td>NEU !! Automatisiert die Zuweisung des richtigen Variablentypes.
Beispiel: auto ObjectInst_o = Object_o;<\/code> Die Variable ObjectInst_o bekommt automatisch den richtigen Typ zugewiesen, n\u00e4mlich den von Object_o.<\/td><\/tr>
Referenz<\/td>u32 &a = b<\/code><\/td>a<\/code> ist nur ein anderer Name von b<\/code>. Es wird keine Kopie von b<\/code> angelegt und a<\/code> zugewiesen, d.h. a<\/code> ist b<\/code>. Es wird auf dieselbe Speicherstelle verwiesen, ohne ein Pointer zu sein.<\/td><\/tr>
for<\/code>-Schleife<\/td>for(u32 x : v) {...}<\/code><\/td>Durchl\u00e4uft eine Schleife ‚f\u00fcr alle x<\/code>-Vorkommen in v<\/code>. v<\/code> k\u00f6nnte dann zum Beispiel ein Array sein oder ein Vector oder ….<\/td><\/tr>
Nullpointer<\/td>nullptr<\/code><\/td>Weist einem Pointer ein Nullpointer-Wert zu.
Beispiel: u32 *ZeigerAufU32_pu32 = nullptr;<\/code><\/td><\/tr>
Enumeratoren<\/td>enum class<\/strong> Color_e { red, blue, green }<\/code><\/td>NEU !! Spezieller enumerator Typ, die class<\/code>nach dem enum<\/code>zeigt an, dass eine Aufz\u00e4hlung stark typisiert ist und daher nur mit diesem enemerator Typ benutzt werden kann. <\/td><\/tr>
Module<\/td>export module Name<\/em><\/code><\/td>NEU !! Mit dem Schl\u00fcsselwort export module<\/code>definiert man ein Modul mit dem entsprechenden Namen dahinter. Alles was nach au\u00dfen hin bekannt sein soll, mu\u00df ebenfalls mit export<\/code>sichtbar gemacht werden. Alles was nicht exportiert wird, ist nachher beim import<\/code>unbekannt.<\/td><\/tr>
Module<\/td>import Name<\/em><\/code><\/td>NEU !! Hier wird ein Modul importiert und alle im Modul mit export<\/code>bekannt gemachten Definitionen importiert.
Beispiel: import std<\/code>importiert die gesamte Standard-Template-Bibliothek als Modul (sollte man immer so machen)<\/em>.<\/td><\/tr>
Namensr\u00e4ume<\/td>namespace Bezeichnung<\/em> { … }<\/td>Deklariert einen neuen Namensbereich Bezeichnung<\/em>. Auf den Namensraum kann mit den Schl\u00fcsselwort using<\/code>zugegriffen werden.<\/td><\/tr>
Namensr\u00e4ume<\/td>using Bezeichnung<\/em><\/code><\/td>Eine using<\/code>-Deklaration macht einen Namen aus einem Namensraum benutzbar.
Beispiel: using Namensraum::Funktion;<\/code>macht die Funktion Funktion<\/em> aus dem Namensraum lokal verf\u00fcgbar.<\/td><\/tr>
Namensraum<\/td>using namespace<\/strong> Bezeichnung<\/em><\/code><\/td>Macht alle Namen im Namensraum Bezeichnung verf\u00fcgbar. Man spart sich Schreibarbeit.
Beispiel: using namespace std<\/code> macht alle Namen im Standardbibliotheksraum verf\u00fcgbar. Man spart sich dadurch die wiederholten std::<\/code>-Qualifikationen f\u00fcr jedem Namen der Standardbibliothek.<\/td><\/tr>
Fehlerbehandlung<\/td>try<\/strong> { code<\/em> } catch<\/strong> (const err_type &err_t) { Err_handling<\/em> }<\/code><\/td>Tritt zur Laufzeit im Code des try<\/code>-Blocks ein Fehler auf, dann wird sofort der catch<\/code>-Block ausgef\u00fchrt. Dem Catch-Block wird eine Referenz mitgegeben, der den Fehlertyp genauer beschreibt. Der Fehlertyp kann dann im Error-Handling ausgegeben werden. Es kann mehrere catch<\/code>-Bl\u00f6cke geben f\u00fcr verschiedene Fehlertypen.<\/td><\/tr>
Fehlerbehandlung<\/td>throw<\/strong> err_hndl<\/em>(\"Text\");<\/code><\/td>throw<\/code> wirft direkt einen Fehler und die entsprechende Fehlerausgabe. <\/td><\/tr>
Fehlerbehandlung<\/td>assert(Bedingung<\/em>);<\/code><\/td>Wenn die Bedingung eines assert()<\/code> im Debug-Modus scheitert, wird das Programm beendet. Ist man nicht Debug-Modus wird nicht gepr\u00fcft.<\/td><\/tr>
Fehlerbehandlung<\/td>static_assert(Bedingung<\/em>, \"Text\");<\/code><\/td>static_assert()<\/code>findet Fehler bereits beim komilieren.<\/td><\/tr>
Fehlerbehandlung<\/td>void Funktion() noexcept<\/strong> { ... }<\/code><\/td>noexcept<\/code>kann benutzt werden um vorzugeben, dass eine Funktion niemals eine Exception werfen soll. Sollte doch ein Fehler auftreten, wird stattdessen das Programm beendet.<\/td><\/tr>
Smart-Pointer<\/td>unique_ptr<\/strong><type> PointerName_p;<\/code><\/td>… definiert einen Pointer PointerName_p<\/em> des Typs type<\/em>.
Beispiel: unique_ptr<\/strong><int> IntegerVar_pui;<\/code><\/td><\/tr>
Konstruktor<\/td>class Klasse_c
{
Klasse_c(type&) = default<\/strong>;
}<\/code><\/td>		Explizite Verwendung des Kopierkonstruktors durch Verwendung von default<\/code>. Andere Standardimplementierungen sind dadurch nicht mehr m\u00f6glich (z.B. Move-Konstruktor).<\/td><\/tr>
Konstruktor<\/td>class Klasse_c
{
Klasse_c(type&) = delete<\/strong>;
}<\/code><\/td>		Die Verwendung von delete<\/code>verbietet die Verwendung eines bestimmten Konstruktors. Im Beispiel links ist die Verwendung des Kopierkonstruktors nicht mehr m\u00f6glich.<\/td><\/tr>
Konstruktor<\/td>class Klasse_c
{
explicit<\/strong> Klasse_c(int s);
}<\/code><\/td>		Die Verwendung von explicit<\/code> erlaubt ausschlie\u00dflich nur die Verwendung dieses Konstruktors. Andere Konstruktoren werden nicht mehr implizit<\/em> verwendet.<\/td><\/tr>
Template<\/td>template<typename<\/strong> T>
class Klasse_c { ... }<\/code><\/td>		Unbeschr\u00e4nktes Typargument:
typename<\/strong><\/code> –> „F\u00fcr alle Typen T…“<\/em><\/td><\/tr>
Template<\/td>template<Element<\/strong> T>
class Klasse_c { ... }<\/code><\/td>		Beschr\u00e4nktes Typargument: (Konzept)
Element<\/strong><\/code> –> „F\u00fcr alle Typen T, sodass Element(T)…“<\/em><\/td><\/tr>
Template<\/td>template<typename...<\/strong> T> class Klasse_c { }; <\/code><\/td>Templates mit variabler Anzahl von Template-Parametern. Diese werden \u2013 wie bei Funktionen und Makros mit variabler Parameteranzahl \u2013 mit ...<\/code> gekennzeichnet
Verwendung:
Klasse_c<int, int, char, std::vector<int>, double> t;<\/code><\/td><\/tr>
Template<\/td>template<typename T, int N<\/strong>> struct buffer { T elem [N]; };<\/code><\/td>Nicht-Typ-Templateparameter
Verwendung:
Buffer<char, 1024> globBuf_o;<\/code><\/td><\/tr>
Template<\/td>template<typename T, typename N>
N foo(const T &s, N n) { }<\/code><\/td>		Funktionstemplate<\/td><\/tr>
Template<\/td>template<typename T><\/code>
class LessThan { const T val;<\/code>
public :<\/code>
LessThan(const T &v) : val(v) {}<\/code>
bool operator()(const \/ &x) const { return x<val} } };<\/code><\/td>		Funktionsobjekt – Die Funktion operator(), implementiert den Anwendungsoperator ()<\/code>.
Verwendung:
LessThan KleinerGleich42(42);
bool b = KleinerGleich42(38)<\/code>

Ergebnis: b ist ‚TRUE‘, da ‚8‘ kleiner ’42‘.<\/td><\/tr>
Lambda Ausdruck<\/td>[capture](parameter) -> return_type { body }<\/code><\/td>Lambda<\/strong> : anonyme Funktion<\/strong> (= Funktion ohne Namen), direkt im Code definiert und ggf. Variablen aus dem umgebenden Scope \u201emitnimmt\u201c.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Schl\u00fcsselw\u00f6rter f\u00fcr Vererbung und Polymorphie<\/h2>\n\n\n\n
Schl\u00fcsselwort \/ Konstruktion<\/th>Verwendung<\/th>Bedeutung \/ Zweck<\/th>Beispiel<\/th><\/tr><\/thead>
virtual<\/code><\/td>in der Basisklasse<\/strong><\/td>Markiert eine Methode als virtuell<\/strong>, d. h. sie kann von abgeleiteten Klassen \u00fcberschrieben<\/strong> werden (erm\u00f6glicht dynamic dispatch<\/em>).<\/td>virtual void speak();<\/code><\/td><\/tr>
override<\/code><\/td>in der abgeleiteten Klasse<\/strong><\/td>Markiert eine Methode, die eine virtuelle Methode aus der Basisklasse \u00fcberschreibt<\/strong>. Der Compiler pr\u00fcft, dass tats\u00e4chlich eine passende virtual<\/code>-Methode existiert.<\/td>void speak() override;<\/code><\/td><\/tr>
final<\/code><\/td>in der abgeleiteten Klasse<\/strong> oder bei einer Methode<\/strong><\/td>\u2460 Bei Klassen: verhindert weitere Vererbung.
\u2461 Bei Methoden: verhindert weitere \u00dcberschreibungen.<\/td>		class Derived final : public Base {};<\/code>
void speak() final override;<\/code><\/td><\/tr>
= 0<\/code><\/td>in der Basisklasse<\/strong><\/td>Macht eine virtuelle Methode abstrakt<\/strong> \u2192 die Klasse wird zur reinen Schnittstelle (abstract base class)<\/strong>.<\/td>virtual void draw() = 0;<\/code><\/td><\/tr>
virtual \u2026 = 0;<\/code><\/td>in der Basisklasse<\/strong><\/td>Kombiniert beide Effekte: virtuelle + abstrakte Funktion \u2192 muss in abgeleiteten Klassen implementiert werden.<\/td>virtual void update() = 0;<\/code><\/td><\/tr>
Base::method()<\/code><\/td>in der abgeleiteten Klasse<\/strong><\/td>Ruft die Implementierung aus der Basisklasse<\/strong> auf (z. B. in \u00fcberschriebenen Methoden).<\/td>Base::speak();<\/code><\/td><\/tr>
using Base::method;<\/code><\/td>in der abgeleiteten Klasse<\/strong><\/td>Macht \u00fcberladene Methoden der Basisklasse sichtbar (verhindert \u00dcberdeckung durch Namensverdeckung).<\/td>using Base::draw;<\/code><\/td><\/tr>
dynamic_cast<>()<\/code><\/td>Laufzeit (RTTI)<\/td>Erm\u00f6glicht sichere Typumwandlung<\/strong> innerhalb einer Vererbungshierarchie; pr\u00fcft zur Laufzeit, ob der Cast g\u00fcltig ist.<\/td>Derived* d = dynamic_cast<Derived*>(basePtr);<\/code><\/td><\/tr>
typeid<\/code><\/td>Laufzeit (RTTI)<\/td>Gibt den tats\u00e4chlichen Typ<\/strong> eines Objekts zur Laufzeit zur\u00fcck (n\u00fctzlich bei polymorphen Basisklassen).<\/td>typeid(*ptr).name();<\/code><\/td><\/tr>
virtual ~Base()<\/code><\/td>in der Basisklasse<\/strong><\/td>Virtueller Destruktor \u2192 sorgt daf\u00fcr, dass beim L\u00f6schen \u00fcber einen Zeiger auf die Basisklasse auch der abgeleitete Destruktor<\/strong> aufgerufen wird.<\/td>virtual ~Base() = default;<\/code><\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Die Standard Template Library (STL)<\/h3>\n\n\n\n

Container<\/h4>\n\n\n\n
\"\"<\/figure>\n\n\n\n
\n\n\n\n

Beziehungen zwischen Klassen in C++<\/h1>\n\n\n\n
Beziehung<\/th>Bedeutung<\/th>Lebensdauer-Abh\u00e4ngigkeit<\/th>Codebeispiel<\/th>\ud83d\udcd0 ASCII-UML<\/th>\ud83c\udfaf Wann sinnvoll?<\/th>\u26a0\ufe0f Typische Fehler<\/th><\/tr><\/thead>
Vererbung<\/strong><\/td>\u201eist-ein\u201c-Beziehung<\/td>Abgeleitete Klasse ist Basisklasse<\/td>class B : public A {};<\/code><\/td>B \u2500\u2500\u2500\u25b7 A<\/code><\/td>Wenn echte Spezialisierung vorliegt<\/td>Vererbung nur zur Wiederverwendung von Code benutzen<\/td><\/tr>
Komposition<\/strong><\/td>Starkes \u201ebesteht aus\u201c<\/td>Teil lebt und stirbt mit Ganzem<\/td>Engine engine;<\/code><\/td>Car \u25c6\u2500\u2500 Engine<\/code><\/td>Wenn Objekt integraler Bestandteil ist<\/td>Zu starke Kopplung erzeugen<\/td><\/tr>
Aggregation<\/strong><\/td>Schwaches \u201ehat ein\u201c<\/td>Teil existiert unabh\u00e4ngig<\/td>Engine* engine;<\/code><\/td>Car \u25c7\u2500\u2500 Engine<\/code><\/td>Wenn Besitz nicht eindeutig ist<\/td>Unklare Besitzverh\u00e4ltnisse<\/td><\/tr>
Assoziation<\/strong><\/td>Benutzt-Beziehung<\/td>Keine Besitzbindung<\/td>void drive(Engine& e);<\/code><\/td>Car \u2500\u2500\u2500 Engine<\/code><\/td>Wenn nur Zusammenarbeit n\u00f6tig<\/td>Verwechslung mit Aggregation<\/td><\/tr>
Abh\u00e4ngigkeit<\/strong><\/td>Kurzzeitige Nutzung<\/td>Nur tempor\u00e4r<\/td>void foo(Engine e);<\/code><\/td>Car ---> Engine<\/code><\/td>Parameter, lokale Nutzung<\/td>Zu viele unn\u00f6tige Includes<\/td><\/tr>
Realisierung (Interface)<\/strong><\/td>Implementiert Vertrag<\/td>Wie Vererbung<\/td>class B : public I {};<\/code><\/td>B --\u25b7 I<\/code><\/td>Polymorphie, Austauschbarkeit<\/td>Interface mit Implementierung vermischen<\/td><\/tr><\/tbody><\/table><\/figure>\n","protected":false},"excerpt":{"rendered":"

Ich habe mir das Buch „Eine Tour durch C++“ (2023) von Bjarne Stroustrup gekauft und werde hier ein paar Extrakte aus dem Buch als Nachschlagewerk zusammenstellen, um die leicht auffindbar zu haben. Referenz Als gutes Nachschlagewerk hat sich die folgende Internetseite etabliert: CPLUSPLUS.COM. Insbesondere ist hier die Standard Template Library sehr gut beschrieben und wird[…]<\/p>\n","protected":false},"author":1,"featured_media":4998,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"zakra_general_container_width":0,"zakra_general_content_width":0,"zakra_general_sidebar_width":0,"zakra_sticky_header":"customizer","zakra_header_main_area":true,"zakra_site_logo_width":0,"zakra_header_top_enabled":"customizer","zakra_header_top_style":"customizer","zakra_primary_menu_item_style":"customizer","zakra_page_header_text_color":"","zakra_page_header_layout":"customizer","zakra_page_title_bg":"","zakra_footer_widgets_bg_image":0,"zakra_page_title_bg_repeat":"customizer","zakra_page_title_bg_position":"customizer","zakra_page_title_bg_size":"customizer","zakra_page_title_bg_attachment":"customizer","zakra_breadcrumbs_enabled":"customizer","zakra_breadcrumbs_text_color":"","zakra_breadcrumbs_separator_color":"","zakra_breadcrumbs_link_color":"","zakra_breadcrumbs_link_hover_color":"","zakra_page_title_bg_image":0,"zakra_footer_widgets_enabled":"customizer","zakra_footer_column_layout_1_style":"customizer","zakra_footer_widgets_bg":"","zakra_footer_widgets_bg_repeat":"customizer","zakra_footer_widgets_bg_position":"customizer","zakra_footer_widgets_bg_size":"customizer","zakra_footer_widgets_bg_attachment":"customizer","zakra_footer_bar_enabled":"customizer","zakra_footer_bar_style":"customizer","zakra_page_container_layout":"customizer","zakra_page_sidebar_layout":"customizer","zakra_remove_content_margin":false,"zakra_sidebar":"customizer","zakra_transparent_header":"customizer","zakra_logo":0,"zakra_main_header_style":"default","zakra_menu_item_color":"","zakra_menu_item_hover_color":"","zakra_menu_item_active_color":"","zakra_menu_active_style":"","zakra_page_header":true,"ngg_post_thumbnail":0,"footnotes":""},"categories":[37],"tags":[],"class_list":["post-4952","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-programmierung"],"_links":{"self":[{"href":"https:\/\/fliegerhorst.dyndns.org\/index.php\/wp-json\/wp\/v2\/posts\/4952","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/fliegerhorst.dyndns.org\/index.php\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/fliegerhorst.dyndns.org\/index.php\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/fliegerhorst.dyndns.org\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/fliegerhorst.dyndns.org\/index.php\/wp-json\/wp\/v2\/comments?post=4952"}],"version-history":[{"count":2,"href":"https:\/\/fliegerhorst.dyndns.org\/index.php\/wp-json\/wp\/v2\/posts\/4952\/revisions"}],"predecessor-version":[{"id":5181,"href":"https:\/\/fliegerhorst.dyndns.org\/index.php\/wp-json\/wp\/v2\/posts\/4952\/revisions\/5181"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/fliegerhorst.dyndns.org\/index.php\/wp-json\/wp\/v2\/media\/4998"}],"wp:attachment":[{"href":"https:\/\/fliegerhorst.dyndns.org\/index.php\/wp-json\/wp\/v2\/media?parent=4952"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/fliegerhorst.dyndns.org\/index.php\/wp-json\/wp\/v2\/categories?post=4952"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/fliegerhorst.dyndns.org\/index.php\/wp-json\/wp\/v2\/tags?post=4952"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}