Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

@@ Zeile 1: / Zeile 1: @@
+====== Glossar: Begriffe aus C++, OOP und Software-Engineering ======
+[[#A]]
+[[#B]]
+[[#C]]
+[[#D]]
+[[#E]]
+[[#F]]
+[[#G]]
+[[#H]]
+[[#I]]
+[[#J]]
+[[#K]]
+[[#L]]
+[[#M]]
+[[#N]]
+[[#O]]
+[[#P]]
+[[#Q]]
+[[#R]]
+[[#S]]
+[[#T]]
+[[#U]]
+[[#V]]
+[[#W]]
+[[#X]]
+[[#Y]]
+[[#Z]]
+> Man sollte die Dinge beim Namen nennen und auf dem aufbauen, was wir schon kennen. Die Mathematik hat keinen kommerziellen Hintergrund.
+> Aber das Computerwesen wird sehr stark von kommerziellen Interessen dominiert, und neue Worte finden eben mehr Gehör.
+>> ---  Niklaus Wirth [European Software Festival 1990]
+===== A =====
+==== abgeleitete Klasse ====
+(engl. derived class, sub class, Kind, Erbe, Unterklasse)\\
+durch [[#Vererbung]]
+aus einer [[#Basisklasse]]
+hergeleiteter benutzerdefinierter [[#Typ]].
+==== abstrakte Klasse ====
+enthält mindestens eine [[#abstrakte Methode|abstrakte Methode]],
+spielt eine wichtige Rolle in [[#Vererbung]]sbeziehungen,
+wo sie Gemeinsamkeiten einer Gruppe von Unterklassen definiert.
+Sie kann keine Objekte bilden. Zuvor muss eine Klasse [[#abgleitete Klasse|abgeleitet]]
+werden, die die bisher abstrakten Methoden redefiniert.
+==== abstrakte Methode ====
+ist bewusst unvollständig, hat keine Implementation,
+ihr Methodenrumpf fehlt.
+Sie ist in [[#abgeleitete_Klasse|abgeleiteten Klasse]] zu [[#Überschreiben von Methoden|überschreiben]].
+==== Abstraktion ====
+(von lat. abstrahere = wegziehen)
+geistige Tätigkeit, um unter einem bestimmten Gesichtspunkt
+wesentliche Merkmale eines Begriffes herauszusondern.
+==== AC/DC ====
+(acquisition in constructor, destructor cleans up),
+siehe [[#RAII-Prinzip]].
+==== ADA ====
+(benannt nach Lady Augusta Ada Byron, Countess of Lovelace)
+Programmiersprache mit [[#PASCAL]]-ähnlicher Syntax
+mit Konzepten für objektbasiertes und generisches (typunabhängiges) Programmieren,
+Ausnahmebehandlung und Nebenläufigkeit.
+Die Standard-Schablonen-Bibliothek (STL) von C++ hatte einen Vorläufer in ADA.
+==== Aggregation ====
+Sonderform der [[#Assoziation]],
+in der die beteiligten [[#Klasse]]n
+eine Teil-Ganzes-Hierarchie darstellen.
+Die Teile sind existenzunabhängig von Ganzen.
+==== Algorithmus ====
+(aus: Dixit algoritmi... = Es sprach al Khoresmi...,
+den Anfangsworten der im 12.Jh. erfolgten lateinischen Übersetzung des
+Buches "Über die indischen Ziffern" von
+Abu Jafar Mohammed ibn Musa al Khowarizmi ca. 780-850,
+- Mohammed, Vater des Jafar, Sohn des Mose aus Choresm, der Gegend um Samarkand und Buchara)
+endliche Folge von eindeutig bestimmten Elementaranweisungen,
+die den Lösungsweg eines Problems exakt und vollständig beschreiben
+[Jochen Ziegenbalg: Algorithmen von Hammurapi bis Gödel. Spektrum, Heidelberg (1996)].
+Ein praktisch durchführbarer Algorithmus muss
+  * korrekt (ohne Fehler),
+  * effektiv (zum richtigen Ergebnis führend),
+  * endlich und effizient sein (in "vernünftiger" Zeit mit verfügbaren Mitteln auskommen).
+In C++ werden bestimmte Standardaufgaben auf Datenmengen als Algorithmen bezeichnet
+und in der Standard-Bibliothek als [[#Schablone]] implementiert.
+==== Almost always auto ====
+Einleitung der Variablendefinition mit dem Schlüsselwort ''auto'' (ab [[#C++11]]).
+Dieser Schreibstil hat den Vorzug, dass eine Anfangswertbelegung der Variable zwingend erforderlich ist.
+==== Aktion ====
+durch eine [[#Botschaft]]
+ausgelöste Operation (Aufruf einer [[#Methode]]).
+==== Anweisung ====
+(engl. statement)\\
+[[#Definition]]
+für den [[#Compiler]]
+oder zur Laufzeit auszuführender Befehl.
+==== Anwendungsfall ====
+(engl. use case)
+Menge von Aktivitäten eines Systems aus der Sicht seiner Akteure,
+die für die Akteure zu einem sichtbaren Ergebnis führen,
+wird stets durch einen Akteur angestoßen.
+==== Anwendungsrahmen ====
+(engl. application framework)
+Menge von zusammenarbeitenden [[#Klasse]]n,
+die einen wiederverwendbaren Entwurf
+für einen bestimmten Anwendungsbereich implementieren,
+besteht aus konkreten und insbesondere [[#abstrakte Klasse]]n,
+die [[#Schnittstelle]]n
+definieren. Im allgemeinen wird vom Programmierer erwartet,
+dass er [[#abgeleitete Klasse]]n definiert, um das Rahmenwerk zu verwenden und anzupassen.
+==== Argument ====
+(seltener: aktueller Parameter)
+Wert, Variable oder [[#Ausdruck]],
+der / die beim [[#Funktionsaufruf]]
+an die Stelle eines formalen [[#Parameter]]s gesetzt wird.
+==== Assoziation ====
+modelliert Verbindungen zwischen [[#Objekt]]en
+einer oder mehrerer [[#Klasse]]n,
+wird beschrieben durch Assoziations- oder Rollennamen und [[#Kardinalität]]en.
+Sonderfälle: [[#Aggregation]], [[#Komposition]].
+==== Assoziationsklasse ====
+Modellelement, das über Eigenschaften einer [[#Klasse]]
+und einer [[#Assoziation]]
+verfügt.
+==== Attribut ====
+OOP: (engl. member data, member variable)
+Variable als Datenbestandteil einer [[#Struktur]]
+oder [[#Klasse]].
+[[#C++11]]: [[kennen:attributspezifizierer]] verstecken compilerspezifische Spracherweiterungen hinter doppelten eckigen Klammern ''[%%%%[ ]]''.
+==== Attributwert ====
+aktuell einem [[#Attribut]]
+zugeordneter Wert.
+==== Ausdruck ====
+(engl. expression)
+ein oder konstanter Wert, [[#Variable]]nname, [[#Funktionsaufruf]]
+oder mehrere, durch geeignete [[#Operator]]en
+verknüpfte Teilausdrücke.
+[[#C++11]] teilt Ausdrücke in folgende Kategorien ein:
+  * [[#lvalue]] : verweist auf ein Objekt (oder eine Funktion),
+  * [[#rvalue]] (prvalue oder xvalue) : kann auf der rechten Seite einer [[#Zuweisung]] stehen,
+  * prvalue ("pure" rvalue) : ein [[#rvalue]], der kein xvalue ist,
+  * xvalue ("expiring" value) : verweist auf ein Objekt nahe seinem Lebensdauer-Ende,
+  * glvalue ("generalisierter" lvalue): lvalue oder xvalue.
+Die drei letztgenannten Begriffe wurden eingeführt, um [[#Verschiebesemantik]] zu ermöglichen.
+            ausdruck
+           /        \
+      glvalue      rvalue
+     /       \    /      \
+  lvalue     xvalue     prvalue
+==== Ausnahme ====
+(engl. exception)
+Situation, in der der "normal" vorgesehene Programmablauf
+nicht mehr sinnvoll fortgesetzt werden kann.
+Der Programmierer hat an einer solchen Stelle die Wahl zwischen mehreren Möglichkeiten:
+  * die Situation ignorieren,
+  * eine Fehlervariable setzen und hoffen, dass der Anwender dies prüft,
+  * irgendwie stillschweigend reparieren,
+  * einen Fehlerwert zurückzugeben, den der Anwender behandeln muss oder
+  *  den "Ausnahmezustand" auszurufen und das Programm soweit zurückzurollen, bis eine [[#Ausnahmebehandlung]] stattfindet.
+In C++ wird auch das den Ausnahmezustand auslösende Objekt als Ausnahme bezeichnet.
+==== Ausnahmebehandlung ====
+(engl. exception handling)
+das Fangen einer geworfenen [[#Ausnahme]]
+und Beheben der Ursachen, die zur Ausnahmesituation geführt haben, oder
+zumindest die Überführung in einen Zustand,
+in dem das Programm sicher, d.h. ohne Ressourcenlecks beendet werden kann.
+===== B =====
+==== Basisklasse ====
+(engl. base class, super class, Elter, Vorfahr, Oberklasse)
+[[#Klasse]], von der durch [[#Vererbung]]
+verwandte, d.h. ähnliche, modifizierte Typen abgeleitet werden.
+==== BCPL ====
+(Basic Combined Programming Language)
+von Martin Richards entworfene Programmiersprache,
+bildete den Ausgangspunkt für die Entwicklung der Programmiersprache C.
+==== Bedingung ====
+ein Testausdruck, der bestimmt, ob eine [[#Anweisung]]
+oder Anweisungsfolge überhaupt ([[#Entscheidung]], [[#Verzweigung]])
+oder wiederholt ([[#Schleife]]) ausgeführt werden muss.
+==== "benutzt ein"-Beziehung ====
+(engl. "uses a" relationship)
+gerichtete [[#Assoziation]],
+in der ein Kunde-Objekt (client) Dienste eine anderen Objektes (server)
+in Anspruch nimmt, um seine Aufgabe zu erfüllen.
+==== Bezeichner ====
+(engl. identifier, Name)
+Folge von Buchstaben, Zifferzeichen oder Unterstrichen zur eindeutigen Benennung
+von [[#Typ]]en, [[#Variable]]n, [[#Funktion]]en oder [[#Namensraum|Namensräumen]].
+==== Beziehung ====
+(engl. relationship)
+Verbindung zwischen Modellelementen mit semantischem Gehalt,
+Oberbegriff für [[#Instanz]]beziehung,
+[[#Assoziation]],
+[[#Aggregation]],
+[[#Komposition]],
+[[#Verallgemeinerung]]
+und [[#Spezialisierung]].
+==== Bibliothek ====
+(engl. library)
+Sammlung von zusammengehörenden Typen und Funktionen,
+insbesondere in vorübersetzter Form,
+die zu einem Anwendungsprogramm hinzu gebunden werden kann oder gar muss,
+wie z.B. die Laufzeitbibliothek.
+Die Verwaltung von Programmteilen ([[#Modul]]en) in Bibliotheken
+erfolgt meist mit einem speziellen Programm,
+Bibliothekar / Archivar (in UNIX: ar) genannt
+==== Binden ====
+(engl. to link, [[#Linker]])
+Vorgang, bei dem (getrennt) übersetzte Programmteile ([[#Modul]]e)
+und [[#Bibliothek]]en zum lauffähigen Programm verbunden werden.
+==== Bindung ====
+C und C++: ordnet dem Funktionsnamen beim Aufruf eine Operation (Befehlsfolge) zu.
+Frühe (statische) Bindung erfolgt zur Übersetzungszeit durch den [[#Linker]],
+späte (dynamische) Bindung bei [[#Polymorphie|polymorphen]] Objekten
+erst zur Laufzeit beim Aufruf der virtuellen Methode.
+Software-Engineering: beschreibt die Stärke der Abhängigkeiten ([[#Kopplung]]) von Funktionen innerhalb eines [[#Modul]]s.
+==== Bitfeld ====
+(engl. bit field structure)
+zusammengesetzter [[#Typ]], dessen einzelne [[#Komponente]]n
+nur einzelne oder wenige Bits umfassen,
+so dass ihre Zusammenfassung platzsparend in einem Maschinenwort
+untergebracht werden kann.
+Wegen der Unterschiede in den Hardwarearchitekturen sind Bitfelder schlecht portierbar.
+==== Block ====
+von einem Paar geschweifter Klammern ''{ }'' eingeschlossene Folge von
+[[#Anweisung]]en. Anweisungsblöcke sind ineinander schachtelbar.
+Der C-Block-[[#Kommentar]]
+''/* Kommentar */'' ist dagegen nicht schachtelbar.
+==== Botschaft ====
+(engl. message, Nachricht)
+Aufforderung an ein [[#Objekt]],
+eine bestimmte Dienstleistung zu erbringen.
+Der Empfänger interpretiert die Botschaft und führt eine Operation aus.
+Durch [[#Polymorphie]]
+kann die Botschaft zum Aufruf einer von mehreren unterschiedlichen
+Operationen führen.
+===== C =====
+==== C++98 ====
+ISO-Standard 14882:1998 Programmiersprache C++, erster Sprachstandard.
+==== C++03 ====
+ISO-Standard 14882:2003 Programmiersprache C++, blieb bis auf kleine Korrekturen unverändert.
+==== C++11 ====
+ISO-Standard 14882:2011 Programmiersprache C++, umfangreiche [[:modern_cpp#C_11|Erweiterung]].
+Die vormalige vorläufige Benennung C++0x wurde zum Insiderwitz: x=0xB ;-)
+==== C++14 ====
+ISO-Standard 14882:2014 Programmiersprache C++, kleinere [[:modern_cpp#C_14|Ergänzungen]].
+==== C++17 ====
+ISO-Standard 14882:2017 Programmiersprache C++,
+bedeutende [[:modern_cpp#C_17|Ergänzungen]] in Sprache und Bibliothek.
+==== C++20 ===
+ISO-Standard 14882:2020 Programmiersprache C++.
+Vorläufige Bezeichnung war C++2a.
+==== C++23 ===
+Abkürzung für den Sprachstandard 2023.
+Vorläufige, inoffizielle Abkürzung war C++2b.
+==== C++26 ===
+Der nächste Standard wird für 2026 erwartet. In Arbeit.
+==== Closure ====
+Einschluss der in der [[#lokal]]en Umgebung definierten, in einem [[#Lambda-Ausdruck]] genutzten Werte oder [[#Referenz]]en.
+==== Compiler ====
+Entwicklungswerkzeug, das einen [[#Quelltext]]
+in Maschinenbefehle übersetzt und diese
+als Datei für ein spätere Ausführung abspeichert.
+Im Gegensatz dazu führt ein Interpreter die Maschinenbefehle sofort aus.
+==== Computer ====
+(engl. Rechner, ehemals auch Mensch, der Rechenaufgaben bearbeitet)
+elektronische Datenverarbeitungsanlage, besteht aus [[#Hardware]] und [[#Software]].
+==== Concept ====
+ab [[#C++20]]
+benannte Anforderung an [[#Schablone]]n, bei der Übersetzung vom [[#Compiler]] ausgewertetes [[#Prädikat]]
+==== Container ====
+Datenbehälter, in C++ typunabhängige [[#Schablone]]n-Klassen,
+die Folgen oder Mengen von gleichartigen Elementen im Hauptspeicher halten.
+Der Anwender wird von Routineaufgaben der Speicherverwaltung entlastet.
+Die [[#Schnittstelle]]
+der Container ist auf die Zusammenarbeit mit [[#Algorithmus|Algorithmen]] abgestimmt.
+==== CRC-Karten ====
+(engl. class, responsibilities, collaborations; Klassenkarten)
+Karteikarten, auf denen der Name der [[#Klasse]],
+ihre Aufgaben ([[#Verantwortlichkeit]]en)
+und ihre [[#Beziehung]]en
+beschrieben werden.
+==== CTAD ====
+(engl. constructor template argument deduction), ab [[#C++17]]
+Herleitung von [[#Schablonen]]-[[#Typ]]-[[#Parameter]]n aus den [[#Argument]]en eines [[#Konstruktor]]s.
+==== CTAD Guide ====
+Hilfsanweisungen für den [[#Compiler]], wie der [[#Typ]] einer [[#Schablone]] aus den [[#Konstruktor]]-[[#Argument]]en hergeleitet werden soll.
+===== D =====
+==== Datenabstraktion ====
+([[#Kapselung]])
+Prinzip, nur die auf ein [[#Objekt]]
+anwendbaren Operationen nach außen sichtbar zu machen.
+==== Definition ====
+Festlegung eines Typs, einer Variable, eines Funktionsrumpfes.
+Jede Definition ist zugleich eine [[#Deklaration]].
+Die Definition eines [[#Bezeichner]]s darf nur genau einmal erfolgen
+([[#one definition rule]]).
+==== Deklaration ====
+Anmeldung eines Namens ([[#Bezeichner]])
+für eine Typ, eine Variable oder eine [[#Funktion]]
+durch Angabe des [[#Funktionskopf]]es.
+Die Deklaration eines Namens kann mehrfach erfolgen,
+darf aber nicht zu Widerspüchen führen.
+Bevor ein Name benutzt werden kann, muss er deklariert werden
+("declare before use").
+Bestimmte Bezeichner dürfen nicht neu deklariert werden,
+da ihnen eine besondere Rolle als [[#Schlüsselwort]]
+zugedacht ist.
+==== Delegation ====
+[[#Objekt]]
+leitet [[#Botschaft]]
+an ein anderes Objekt weiter ([[#Kollaboration]]).
+==== Destruktor ====
+Methode, die (automatisch) beim Zerstören eines [[#Objekt]]es
+ausgeführt wird, soll u.a. dynamisch belegte Ressourcen (z.B. Speicher)
+freigeben,die während der [[#Lebensdauer]]
+im Besitz des Objektes waren.
+===== E =====
+==== Einfachvererbung ====
+(engl. single inheritance)
+Jede [[#Klasse]]
+besitzt maximal eine direkte [[#Basisklasse]].
+Es entsteht eine Baumstruktur ([[#Vererbungshierarchie]]).
+==== Element ====
+Bestandteil einer Folge, z.B. einem [[#Feld]]
+oder Datenwert in einem [[#Container]].
+==== Entscheidung ====
+(bedingte Anweisung)
+[[#Steueranweisung]],
+die anhand einer [[#Bedingung]]
+entscheidet, ob eine [[#Anweisung]]
+oder Anweisungsfolge ausgeführt oder übersprungen werden muss.
+Die Auswahl zwischen zwei oder mehreren möglichen
+Anweisung(sfolg)en heißt [[#Verzweigung]].
+==== Entwurfsmuster ====
+(engl. design pattern)
+bewährte, allgemeine Lösung für ein wiederkehrendes Entwurfsproblem.
+Ein Muster ist keine fertige Lösung, es beschreibt nur den Lösungsweg.
+==== Erben einer Implementation ====
+Einsatz der [[#Vererbung]]stechnik
+zur Wiederverwendung von Code.
+Eine "ist implementiert mit Hilfe von"-Beziehung kann auch durch eine
+[[#Komposition]]
+realisiert werden.
+==== Erben einer Schnittstelle ====
+Einsatz der [[#Vererbung]]stechnik,
+um gemeinsame [[#Schnittstelle]]n
+(Oberbegriffe) für eine Hierarchie von [[#abgeleitete Klasse|abgeleiteten Klassen]] festzulegen,
+deren Verhalten durch [[#Überschreiben von Methoden|Überschreiben]]
+ihrer [[#virtuelle Methode|virtuellen Methoden]]
+und [[#Polymorphie]]
+angepasst wird.
+===== F =====
+==== Faktorisierung ====
+Herauslösen und Zusammenfassen der Gemeinsamkeiten verwandter Klassen
+zu einer gemeinsamen [[#Basisklasse]].
+==== Faltausdruck ====
+(engl. fold expression), ab [[#C++17]]
+löst ein [[#Parameter pack]] mittels [[#Operator]]en auf.
+ Siehe [[wp>Fold (higher-order function)]].
+==== Feld ====
+(engl. array, vector, indizierte Variable, Reihe)
+Variable, die eine Folge von Datenwerten (Elementen) enthält.
+Ein [[#Element]]
+eines eindimensionalen Feldes
+kann über den [[#Index]]
+angesprochen werden.
+Felder können mehrstufig aufgebaut sein (zwei- und höherdimensional),
+dann erfolgt der Elementzugriff mit mehreren Indizes.
+==== Formatierung ====
+Gestaltung des Quelltextes durch zusätzliche Leerzeichen und Zeilenumbrüche,
+erhöht die Lesbarkeit und Erfassungsgeschwindigkeit für den menschlichen Leser.
+Formatierung beeinflusst auch das Erscheinungsbild der Ein- und Ausgaben in Programmen:
+Zahlen werden intern kompakt als Bitmuster gehalten,
+bei der Kommunikation mit dem Menschen (oder anders aufgebauter Hardware)
+jedoch als lesbare Zeichenfolgen übermittelt.
+==== FORTRAN ====
+(aus FORmula TRANslator; IBM, John Backus 1954)
+erste "höhere" Programmiersprache, die einen [[#Compiler]]
+erforderte. Da sie erstmals den Programmierern die Arithmetik
+auch für gebrochene Zahlen "zurück" gab, existieren bis heute
+umfangreiche numerische Programmbibliotheken im technischen Bereich.
+==== Freund ====
+(engl. friend)
+[[#Klasse]]
+oder [[#Funktion]],
+die [[#Zugriffsrecht]]
+auf nichtöffentliche Bestandteile einer Klasse hat.
+Dieses Zugriffsrecht wird bei der [[#Definition]]
+der Klasse verliehen, auf deren Bestandteile zugegriffen werden soll.
+Die Klasse selbst legt fest, wen sie zum Freund haben will.
+Eine nachträgliche "Anbiederung" ist nicht möglich.
+==== Funktion ====
+(engl. function, subroutine)
+Programmteil, der eine Folge von [[#Anweisung]]en
+unter einem Namen ([[#Bezeichner]]) zusammenfasst.
+Durch Nennung des Funktionsnamens ([[#Funktionsaufruf]])
+kann diese Anweisungsfolge an beliebigen Stellen im Programm
+als Unterprogramm ausgeführt werden.
+Die Anweisungen innerhalb der Funktion können von [[#Parameter]]n
+abhängig sein, die der Funktion beim Aufruf als [[#Argument]]e
+mitgegeben werden.
+Eine Funktion kann als Ergebnis einen Rückgabewert liefern
+oder auch [[#Seiteneffekt]]e hervorrufen.
+Kommt es nur auf den Seiteneffekt kann,
+braucht eine Funktion in C und C++ keinen Rückgabewert zu liefern,
+der Aufrufer kann einen gelieferten Rückgabewert auch ignorieren
+(verwerfen).
+Funktionen im strengen,
+mathematischen Sinn überführen Argumentwerte ohne Seiteneffekte
+in einen eindeutig bestimmten Wert vom [[#Rückgabetyp]]
+(Funktion = math. eindeutige, injektive Abbildungsvorschrift
+vom Definitionsbereich in den Ergebnisbereich).
+In diesem strengeren Sinn wird ein Unterprogramm ohne Rückgabewert
+als [[#Prozedur]]
+bezeichnet.
+==== Funktionsaufruf ====
+(engl. function call, Auswertung)
+verursacht die Abarbeitung der irgendwo im Programm definierten Anweisungsfolge
+durch Nennung des vorher deklarierten Funktionsnamens,
+gefolgt von runden Klammern mit der passenden Anzahl von [[#Argument]]-Werten
+in einem [[#Ausdruck]].
+Der entstehende Ergebniswert vom [[#Rückgabetyp]]
+kann zur weiteren Berechnung genutzt werden
+(sofern die Funktion nicht vom [[#Typ]]
+''void'' ist).
+==== Funktionskopf ====
+(engl. function prototype)
+verbindet [[#Rückgabetyp]],
+[[#Bezeichner]]
+und Liste der [[#Parameter]]
+zur [[#Deklaration]]
+einer [[#Funktion]].
+==== Funktionsobjekt ====
+(Funktor)
+Objekt von einem zusammengesetzten [[#Typ]],
+das wie eine [[#Funktion]]
+für einen [[#Funktionsaufruf]]
+genutzt werden kann.
+Für diesen Typ muss der [[#Operator]]
+''operator()'' als [[#Methode]]
+definiert sein.
+==== Funktionsrumpf ====
+(engl. function body)
+[[#Block]], der auf einen [[#Funktionskopf]]
+folgt, ist die [[#Definition]]
+der Anweisungen, die beim [[#Funktionsaufruf]]
+abzuarbeiten sind.
+==== Funktionsschablone ====
+(engl. template function)
+als [[#Schablone]]
+definierte [[#Funktion]]
+mit mindestens einem allgemein gehaltenen Parametertyp.
+==== Funktor ====
+([[#Funktionsobjekt]])
+==== fußgesteuerte Schleife ====
+[[#Schleife]],
+deren Wiederholungs-[[#Bedingung]]
+nach dem Schleifenrumpf steht.
+Der Anweisungs-[[#Block]]
+wird mindestens einmal durchlaufen (nicht abweisender Test).
+===== G =====
+==== geächtet ====
+Veraltete Teile des Sprachstandards können in künftigen Standards entfernt werden. Es gibt bessere Lösungen.
+==== Geheimnisprinzip ====
+(engl. information hiding)
+von [[wp>David Lorge Parnas]] 1971 formulierte Forderung des Software-Entwurfs, dass
+  *  Anwender nur die Schnittstelle der von ihnen genutzten Bibliotheken, jedoch nicht ihren inneren Aufbau kennen müssen,
+  *  Bibliotheksprogrammierer nur die Anforderungen an die Schnittstellen, jedoch nicht deren Anwendungen kennen müssen,
+damit die [[#Modularisierung]] zu sauber entkoppelten Programmbausteinen führt.
+==== Geltungsbereich ====
+(engl. scope)
+Quelltextabschnitt, in dem ein [[#Bezeichner]]
+bekannt ist ([[#lokal]], [[#global]], [[#Klasse]], [[#Namensraum]]).
+==== generisch ====
+(allgemeingültig, typunabhängig)
+[[#Definition]]
+und Anwendung von [[#Schablone]]n.
+==== global ====
+nicht von [[#Block]]-Klammern umgeben, im gesamten Programm existent, zugreifbar.
+==== Grammatik ====
+(grch. syntax)
+Satz von Regeln, der die Reihenfolge von Bausteinen einer Sprache festlegt.
+Für formale Sprachen verbreitet ist die Darstellung
+als (erweiterte) Backus-Naur-Form (BNF, EBNF).
+Die "Satzbauregeln" werden vom [[#Compiler]]
+beim Übersetzen geprüft, ihre Nichteinhaltung wird bemerkt und bemängelt,
+dann entsteht kein lauffähiges Programm.
+Gefährlicher als Syntax-Fehler sind logische Fehler (Denkfehler),
+weil diese nicht vom Compiler abgefangen werden.
+Sie können nur durch sorgfältige Prüfung oder
+Testläufe mit entsprechenden Eingangsdaten erkannt werden.
+Der Aufwand zur Fehlererkennung kann beträchtlich sein.
+===== H =====
+==== "hat ein"-Beziehung ====
+(engl. "has a" relationship, [[#Komposition]], [[#Aggregation]])
+in umgekehrter Richtung: "ist Teil von".
+==== Hardware ====
+Gesamtheit aller elektronischen und mechanischen Bestandteile eines [[#Computer]]systems.
+==== Header ====
+(Vorspanndatei, prototype file)
+Quelltextdatei, die [[#Funktion]]en,
+seltener [[#global]]e [[#Variable]]n,
+[[#Deklaration|deklariert]].
+[[#Typ]]en und [[#Konstante]]n
+können [[#Definition|definiert]] werden.
+Die fehlerhafte mehrfache Definition muss unterbunden werden.
+Headerdateien enthalten alle notwendigen Informationen
+über die [[#Schnittstelle]]n von [[#Modul]]en
+und benutzerdefinierten [[#Typ]]en.
+==== Heap ====
+(dt. Halde)
+Als [[wpde>Heap_(Datenstruktur)|Heap]] wird ein teilweise geordneter Binärbaum bezeichnet, dessen Kindknoten niemals größer sind als deren Elternknoten (Maximum-Heap).
+Darüber hinaus besitzt der Heap eine "Formeigenschaft" --- er ist ausgeglichen bis auf die letzte Ebene, der nach rechts hin Blattknoten fehlen dürfen.
+Damit kann der Heap als Sequenz ohne Lücken aufgefasst werden:
+       6
+   7   2   4   ==>   9 8 6 5 7 2 4 1 3 0
+3 0
+Manchmal wird der Freispeicherbereich eines Programms für die dynamischer Speicherverwaltung ebenfalls als Heap bezeichnet.
+===== I =====
+==== Identität ====
+unterscheidet ein [[#Objekt]]
+von allen anderen, auch wenn es möglicherweise gleiche Attributwerte hat.
+Programmiersprachen und Datenbanksysteme nutzen Variablennamen,
+um temporäre Objekte zu unterscheiden.
+Sie vermischen Addressierbarkeit und Identität.
+Datenbanksysteme nutzen Identifikatorwerte,
+um persistente Objekte zu unterscheiden. Sie vermischen Datenwert und Identität.
+Der Übergang von temporären Speicheradressen individueller Objekte
+und zu persistenten Identifikatoren der Objekte auf Massenspeichern,
+und vor allem zurück,
+ist das Hauptproblem bei der Implementierung von [[#Persistenz]].
+Den Unterschied zwischen dem Namen des Objektes und dem Objekt selbst nicht zu erkennen,
+ist die Quelle vieler Fehler in der objektorientierten Programmierung.
+==== IILE ====
+(engl. immediately invoked lambda expression)
+[[#Lambda-Ausdruck]], der durch [[#Funktionsaufruf]] sofort ausgewertet wird.
+==== Index ====
+(lat. index = Zeiger, Zeigefinger)
+ganzzahliger Wert, mit dessen Hilfe die [[#Element]]e
+eines [[#Feld]]es
+durchnummeriert und angesprochen werden.
+Zur Kennzeichnung eines Index
+dienen in C und C++ eckige Klammern: ''strasse[hausNr]''.
+Die Nummerierung beginnt mit ''feld[0]''
+und endet mit ''feld[anzahl-1]''.
+Fehlerhafte Indizierung wird nicht abgefangen
+und führt zu schwer auffindbaren Laufzeitfehlern.
+Wird die Ganzzahligkeit des Index fallengelassen,
+spricht man von einem "assoziativen Feld".
+==== Instanz ====
+(engl. instance, [[#Objekt]], Variable vom [[#Klasse]]ntyp)
+unzulässige (?) Bedeutungsüberwälzung
+vom engl. instance "Beispiel, Fall"
+auf das gleichlautende dt. Instanz "zuständige Behörde, Gericht",
+aus mittellat. instans "drängend, heftig", eigentl. "darauf (be)stehend".
+==== "ist ein"-Beziehung ====
+(engl. "is a" relationship)
+Zugehörigkeits-[[#Beziehung]]
+zwischen einem [[#Objekt]]
+und seiner [[#Klasse]].
+==== "ist eine Art von"-Beziehung ====
+(engl. "is a kind of" relationship)
+asymmetrische Teilmengen-[[#Beziehung]]
+einer [[#abgeleitete Klasse|abgeleiteten Klasse]]
+und ihrer [[#Basisklasse]].
+==== Iterator ====
+(von lat. iterare = wiederholen)
+zeigerartiges Objekt, mit dessen Hilfe Folgen von Objekten
+in einem [[#Feld]]
+oder einem [[#Container]]
+durchlaufen und angesprochen werden.
+===== J =====
+===== K =====
+==== Kapselung ====
+(engl. encapsulation, data hiding)
+Einschließen und bewusstes Verbieten der Manipulation
+von internen Daten durch außenstehende Anwender
+zum Schutz vor unzulässigen inneren Zuständen.
+Nach außen wird eine [[#Schnittstelle]]
+bereitgestellt.
+Da das Verbot der Manipulation ([[#Zugriffsrecht|Zugriffsschutz]])
+oft mit dem Verbergen von Information
+über den inneren Aufbau durch opake (undurchsichtige) Typen
+verbunden wird, werden Kapselung und [[#Geheimnisprinzip]]
+gern verwechselt.
+==== Kardinalität ====
+Anzahl der Elemente in einer [[#Beziehung]].
+==== Klasse ====
+(engl. class)
+zusammengesetzter [[#Typ]]
+aus [[#Attribut]]en
+und [[#Methode]]n
+zu deren Bearbeitung.
+Durch Einschränkung der [[#Zugriffsrecht]]e
+kann eine [[#Kapselung]]
+erreicht werden.
+Variablen eines Klassen-Typs werden als [[#Objekt]]e
+bezeichnet.
+Im mathematischen Sinn ist eine Sammlung von
+Objekten mit mindestens einem gemeinsamen Merkmal eine Klasse.
+Danach müssten zumindest alle zu leeren Klassendefinitionen gehörenden Objekte
+denselben Typ besitzen.
+In C++ sind jedoch Klassen auch bei gleichen inneren Merkmalen
+anhand ihres verschiedenen Namens unterscheidbar.
+==== Klassenbibliothek ====
+(engl. class library)
+organisierte Sammlung von [[#Klasse]]n.
+==== Klassendefinition ====
+[[#Definition]],
+legt [[#Attribut]]e einer [[#Klasse]]
+fest, deklariert [[#Funktionskopf|Köpfe]] von [[#Methode]]n
+und verleiht [[#Zugriffsrecht]]e.
+==== Klassendeklaration ====
+[[#Deklaration]],
+führt einen Klassennamen ein, muss die [[#Klasse]]
+aber nicht [[#Klassendefinition|definieren]].
+==== Klassendiagramm ====
+stellt die Konzepte [[#Klasse]],
+[[#Attribut]]e,
+[[#Methode]]n
+und [[#Beziehung]]en
+([[#Vererbung]], [[#Assoziation]])
+in grafischer Form dar.
+==== Klassenentwurf ====
+(engl. class design)
+Identifikation und Beschreibung der Merkmale einer [[#Klasse]],
+Aufteilung ([[#Faktorisierung]]) zu großer
+und Verschmelzung zu kleiner, nicht tragfähiger Konzepte.
+Entwurfsziele sind
+  * geringe Kopplung zwischen den Klassen,
+  * starke Kohäsion innerhalb einer Klasse,
+  * Hinlänglichkeit (genügend Merkmale), um eine eigenständige Klasse zu bilden,
+  * Vollständigkeit der Schnittstelle,
+  * Einfachheit der Operationen.
+==== Klassenschablone ====
+(engl. template class)\\
+typparametrisierte [[#Klasse]],
+wird als [[#Schablone]]
+definiert.
+==== Klassenvariable ====
+(engl. static member data)
+Variable im [[#Namensraum]]
+der [[#Klasse]],
+die nur einmal für die gesamte Klasse ,
+unabhängig von der Existenz von [[#Objekt]]en
+vorhanden ist.
+Sie muss für das [[#Binden]]
+außerhalb der Klasse in einem [[#Modul]]
+definiert werden.
+==== Kollaboration ====
+(Zusammenarbeit)
+Kontext einer Menge von Interaktionen.
+==== Kollaborationsdiagramm ====
+ein um [[#Botschaft]]en
+erweitertes [[#Objektdiagramm]],
+zeigt Interaktionen zwischen ausgewählten Objekten in einer bestimmten begrenzten Situation
+und betont die Beziehungen zwischen den Objekten und ihre Anordnung.
+==== Kommentar ====
+(engl. comment)
+Quelltextabschnitt, der nichts zum Programm beiträgt,
+sondern nur zur Information des menschlichen Lesers gedacht ist.
+C++ kennt zwei Arten von Kommentaren:
+  * Kommentare im [[#BCPL]]-Stil bis zum Zeilenende,
+  * Blockkommentare im C-Stil.
+==== Komplexität ====
+  * ** Laufzeitkomplexität, Speicherkomplexität ** : Die Problemkomplexität kennzeichnet das Laufzeitverhalten bzw. den Speicherbedarf eines [[#Algorithmus]] in Bezug auf die "Problemgröße".
+  * ** Entwurfskomplexität ** : Die Komplexität eines Software-Entwurfs ist ein Maß dafür, wieviele Funktionen, Module, Klassen, Teilsysteme miteinander in Beziehung treten.
+==== Komponente ====
+(engl. member)
+(Daten-)Bestandteil eines zusammengesetzten [[#Typ]]s.
+==== Komposition ====
+strenge Form der [[#Aggregation]],
+bei der die Teile vom Ganzen existenzabhängig sind.
+Beim Löschen des Ganzen werden auch alle Teile gelöscht.
+Jedes Teil kann zu einem Zeitpunkt immer nur zu einem Ganzen gehören,
+kann jedoch evtl. einem anderen Ganzen zugeordnet werden.
+==== Konkretisierung ====
+([[#Spezialisierung]])
+Ableitung einer konkreten [[#Klasse]]
+aus einer [[#abstrakte Klasse|abstrakten Klasse]]
+durch [[#Vererbung]]
+und [[#Überschreiben von Methoden|Überschreiben]]
+aller [[#abstrakte Methode|abstrakten Methoden]],
+Bei [[#Schablone]]n
+[[#Definition]]
+eines konkreten Typs durch Festlegen der Typparameter einer Schablone.
+==== Konstante ====
+unveränderlicher Wert.
+Dies kann ein Literal sein (eine Zeichenfolge für eine Zahl, ein Zeichen oder eine Zeichenkette)
+oder ein mit ''#define'' festgelegter Bezeichner,
+den der [[#Präprozessor]]
+beim Übersetzen in ein Literal umwandelt.
+Als ''const'' markierte Variablen dürfen ihre Werte ebenfalls nicht ändern.
+Für sie sind die [[#Zuweisung]],
+das Erhöhen und Absenken sowie das Einlesen aus Datenströmen untersagt.
+Konstante [[#Methode]]n
+haben nur Leserechte. Sie können nur lesend auf [[#Attribut]]e
+zugreifen und dürfen wiederum nur ''const''-Methoden aufrufen.
+Andererseits sind allein konstante Methoden bei konstanten [[#Objekt]]en
+aufrufbar.
+==== Konstruktor ====
+(engl. constructor, object factory, Fabrikmethode)
+zur [[#Klasse]]
+gehörende Erzeugerfunktion für ein [[#Objekt]],
+die das Objekt anlegt und dessen [[#Attribut]]e
+mit gültigen Werten belegt.
+Eine [[#Klasse]]
+kann mehrere Konstruktoren mit unterschiedlichen
+[[#Parameter]]listen besitzen.
+Ein Konstruktor ohne Parameter wird Standardkonstruktor genannt.
+==== Kontravarianz ====
+(lat. kontravariant = sich entgegengesetzt verändernd)
+Parametertypen von Methoden können beim Überschreiben allgemeiner gemacht werden.
+Die Implementierung kann toleranter sein und einen allgemeineren Typ zulassen.
+Die [[#Spezialisierung]]
+der implementierenden [[#Klasse]]
+geht einher mit gegenläufiger [[#Verallgemeinerung]]
+des Parametertyps. [ [[#Quellen|Informatik-Handbuch]] ]
+Diese Art von Kontravarianz ist in C++ nicht möglich,
+da beim [[#Überschreiben von Methoden|Überschreiben]]
+die Parameterliste exakt gleich lauten muss.
+Andernfalls wird eine andere [[#Methode]]
+definiert ([[#Überladen]]),
+deren Existenz bei den Aufrufen zu Mehrdeutigkeiten führt.
+Ein [[#Zeiger]]
+auf einen Bestandteil ([[#Attribut]]
+oder [[#Methode]]) einer [[#Basisklasse]]
+kann sicher an einen Zeiger auf ein Bestandteil einer [[#abgeleitete Klasse|abgeleiteten Klasse]]
+übertragen werden,
+weil jede abgeleitete Klasse auch alle Bestandteile der Basis besitzt,
+aber nicht umgekehrt.
+Diese Kontravarianz-Regel in C++ scheint das Gegenteil der Regel zu sein,
+dass man einen Zeiger auf ein abgeleitetes Objekt an einen Basiszeiger
+übergeben kann ([[#Polymorphie]]).
+Tatsächlich garantieren beide Regeln,
+dass ein Zeiger nie auf Objekt zeigt,
+welches nicht mindestens die versprochenen Eigenschaften hat.
+==== Kopierkonstruktor ====
+(engl. copy constructor)
+erzeugt ein [[#Objekt]]
+als Kopie eines schon existierenden Objektes
+i.a. mit denselben [[#Attribut]]werten.
+==== kopfgesteuerte Schleife ====
+[[#Schleife]],
+deren Durchführungs-[[#Bedingung]]
+vor dem Schleifenrumpf steht.
+Der Anweisungs-[[#Block]]
+wird nur durchlaufen, wenn die Bedingung erfüllt ist (abweisender Test).
+Nach Abarbeitung des Schleifenrumpfes wird der Test wiederholt.
+==== Kopplung ====
+Software-Engineering: beschreibt die Stärke und Anzahl der Abhängigkeiten zwischen Einheiten eines Software-Systems ([[#Modul]]en).
+==== Kovarianz ====
+(lat. kovariant = sich mit verändernd)
+[[#Rückgabetyp]]en
+können beim [[#Überschreiben von Methoden]]
+spezieller werden. Diese entsprechen wegen [[#Vererbung]]
+immer noch der in der [[#Basisklasse]]
+definierten [[#Schnittstelle]].
+Die [[#Spezialisierung]]
+der implementierenden Klasse
+geht mit der gleichgerichteten Spezialisierung des Rückgabetyps einher.
+===== L =====
+==== Lambda-Ausdruck ====
+(engl. lambda expression), ab [[#C++11]]
+aus funktionalen Programmiersprachen übernommenes Konzept einer anonymen oder Adhoc-[[#Funktion]].
+Diese [[#Funktionsobjekt]]e können lokal an der Stelle ihrer Benutzung definiert werden.
+Sie übernehmen dabei wahlweise Werte oder Referenzen ihrer Umgebung ([[#Closure]]).
+==== Lebensdauer ====
+(engl. lifetime)\\
+Existenzdauer einer [[#Variable]].
+C++ bietet drei Speicherkonzepte ([[#Speicherklasse]]n) an:
+  * Für automatische ([[#lokal]]e) Variable werden auf dem Stapelspeicher angelegt. Sobald die Programmausführung die [[#Definition]] der Variable erreicht, wird deren [[#Konstruktor]] aufgerufen (sofern der [[#Typ]] einen besitzt). Verlässt der Programmablauf den die Definition umschließenden [[#Block]], wird ihr [[#Destruktor]] aufgerufen und der Stapel abgebaut.
+  * Statische und [[#global]]e Variable werden im Datensegment angelegt, vor Beginn des Hauptprogramms mit Anfangswerten belegt und nach dem Verlassen des Hauptprogramms zerstört. Konstruktoren und Destruktoren können so auch Aktionen vor Beginn und nach Ende des Hauptprogramms ausführen. Allerdings wird nicht garantiert, in welcher Reihenfolge dies für Variablen in verschiedenen [[#Modul]]en geschieht.
+  * Dynamische, durch [[#Zeiger]] referenzierte Variablen erhalten auf Anforderung Adressen auf dem Heap ("Halde") zugewiesen. Sie können vom Programmierer zu beliebigem Zeitpunkt wieder vernichtet werden. Dies sollte in C++ auch durch den Programmierer geschehen, um kein Speicherleck zu erzeugen,  denn C++ besitzt keine automatische [[#Speicherbereinigung]].
+==== Linker ====
+Entwicklungswerkzeug, welches (getrennt) übersetzte Programmteile ([[#Modul]]e)
+und [[#Bibliothek]]en zum lauffähigen Programm [[#Binden|zusammenfügt]].
+In UNIX heißt dieses Programm "loader" (ld).
+==== Logik ====
+(hier: zweiwertige Aussagenlogik)
+grundlegendes Teilgebiet der Mathematik.
+Der Logikkalkül wurde von George Boole (1815-1864) ausgearbeitet.
+Aussageformen (Prädikate) lassen sich als ''bool''-[[#Funktion]]en
+formulieren. Sie liefern jeweils einen von zwei Wahrheitswerten
+(''true'' oder ''false'').
+Diese können mit den Junktoren (logischen Operatoren) UND ODER NICHT
+verknüpfen.
+Logische Ausdrücke dienen als [[#Bedingung]]
+der Tests in [[#Schleife]]n
+und [[#Entscheidung]]en.
+==== lokal ====
+innerhalb eines [[#Block]]es definiert, gültig, zugreifbar.
+==== lvalue ====
+(engl. left hand value)
+[[#Ausdruck]],
+der auf der linken Seite einer [[#Zuweisung]]
+zulässig ist (aus [[#BCPL]]).
+===== M =====
+==== Makro ====
+durch ''#define'' festgelegter Bezeichner,
+der vom [[#Präprozessor]]
+ausgewertet und bei weiteren Vorkommen im Quelltext ersetzt wird.
+==== Makrofunktion ====
+ein [[#Makro]]
+mit Klammern und [[#Parameter]]n.
+==== Mehrfachvererbung ====
+(engl. multiple inheritance)
+[[#Vererbung]]
+von mehreren [[#Basisklasse]]n
+zu einer [[#abgeleitete Klasse|abgeleiteten Klasse]].
+Gleichnamige [[#Attribut]]e
+oder [[#Methode]]n
+in den Basisklassen ruft Namenskonflikte hervor,
+die nachträglich aufgelöst werden müssen.
+==== Mehrfachverzweigung ====
+[[#Verzweigung]]
+mit mehr als zwei möglichen Ausgängen (Anweisungsfolgen).
+==== Methode ====
+(engl. member function, Operation)
+innerhalb einer [[#Klasse]]
+definierte Funktion, kann nur für ein [[#Objekt]]
+der Klasse ausgerufen werden.
+Methoden legen das Verhalten der Objekte fest.
+In der objektorientierten Denkweise wird das Ausführen
+der Operation als Reaktion des Objektes auf eine [[#Botschaft]],
+den [[#Funktionsaufruf]],
+aufgefasst.
+Die Methode hat Zugriff auf die [[#Attribut]]e
+des Objektes und auf [[#Klassenvariable]]n.
+Nichtkonstante Methoden können den Objektzustand ändern.
+==== Methodendefinition ====
+kann (und sollte in C++ zumeist) außerhalb der [[#Klassendefinition]]
+erfolgen (Trennung von [[#Schnittstelle]]
+und Implementierung, [[#Geheimnisprinzip]]).
+==== Methodendeklaration ====
+erfolgt bei der [[#Klassendefinition]].
+==== Modul ====
+C und C++: Quelltext oder Menge von Quelltexten, die als [[#Übersetzungseinheit]] vom [[#Compiler]]
+in eine [[#Objektdatei]]
+übersetzt wird.
+C++20: kann aus mehreren Quellen (Schnittstelle, Implementierungen und Partitionen) bestehen.
+Software-Engineering:
+Ein Modul als (wiederholt verwendbarer) Programmbaustein
+ist eine Sammlung inhaltlich zusammengehörender Funktionen.
+Diese können für sich in einem Testrahmen überprüft werden,
+bevor sie in ein größeres Programm integriert werden.
+==== Modularisierung ====
+Aufteilung der Programmquellen in [[#Modul]]e
+zur Verringerung der [[#Komplexität]]
+eines Programmentwurfes.
+Angestrebt sind enge [[#Bindung]] innerhalb eines Moduls und lose [[#Kopplung]] zwischen Modulen.
+Modularisierung erlaubt verteiltes Programmieren
+und frühzeitige Tests.
+==== Most vexing parse ====
+(dt. etwa: irreführendste Lesart)
+Die Grammatik von C++ liest ''X f(Y());'' als [[#Deklaration]] einer [[#Funktion]] ''f(Y)'' mit dem Rückgabetyp ''X'',
+während (unerfahrene?) Programmierer das meist als [[#Definition]] einer [[#Variable]] ''X'' auffassen, deren [[#Konstruktor]] eine temporäre Variable vom Typ ''Y'' übernimmt.
+Die [[#uniform initialization]] mit geschweiften Klammern ([[#C++11]]) schafft hier Abhilfe, aber Vorsicht!
+<code cpp>
+std::vector<int> fkt(std::istream_iterator<int>(std::cin), std::istream_iterator<int>()); // Funktionsdeklaration
+std::vector<int> vec(std::istream_iterator<int>{std::cin}, std::istream_iterator<int>{}); // Variablendefinition
+std::vector<int> err{std::istream_iterator<int>{std::cin}, std::istream_iterator<int>{}}; // Fehler: Initialisiererliste enthält keine int-Werte!
+</code>
+===== N =====
+==== Namenskonvention ====
+Übereinkunft einer Gruppe von Programmierern über die Schreibweise von [[#Bezeichner]]n.
+==== Namensraum ====
+(engl. namespace)
+[[#Block]], der die Sichtbarkeit von [[#Bezeichner]]n
+beschränkt und dadurch die "Verschmutzung" des globalen
+Namensraums mit gleichnamigen Bezeichnern verhindert.
+Die Standard-Bibliothek definiert ihre Bezeichner
+im Namensraum ''std''.
+Der Anwender kann bei Bedarf qualifizierte Namen benutzen,
+einzelne Namen oder ganze Namensbereiche importieren.
+Eine [[#Klasse]]
+ist gleichzeitig Namensraum für die darin deklarierten Namen.
+===== O =====
+==== Objekt ====
+(engl. object, instance variable)
+Variable eines Klassentyps.
+Ein Objekt belegt alle in der [[#Klasse]]
+definierten [[#Attribut]]e
+mit individuellen Werten ([[#Identität]])
+und kann die in der [[#Klasse]]
+deklarierten [[#Methode]]n
+ausführen.
+Die Methoden legen das [[#Verhalten]]
+des Objektes fest.
+Die Attributwerte repräsentieren den [[#Zustand]]
+des Objektes.
+(Nicht konstante) Methoden können den Zustand ändern.
+==== Objektdatei ====
+vom [[#Compiler]]
+aus einem [[#Quelltext]]
+erzeugtes Zwischenprodukt mit verschieblichem Maschinencode,
+das in [[#Bibliothek]]en
+aufgenommen oder beim [[#Binden]]
+zu einem ausführbaren Programm komplettiert wird.
+==== Objektdiagramm ====
+grafische Darstellung der Objekt-[[#Beziehung]]en
+zu einem bestimmten Zeitpunkt, siehe auch
+[[#Kollaborationsdiagramm]].
+==== objektorientiert ====
+enhält drei Konzepte: [[#Objekt]], [[#Klasse]], [[#Vererbung]].
+==== objektorientierte Analyse (OOA) ====
+verwendet die Konzepte [[#Objekt]], [[#Klasse]], [[#Attribut]],
+[[#Methode]], [[#Assoziation]], [[#Vererbung]], [[#Botschaft]]
+zur Modellierung der Anforderungen an ein Softwareprodukt.
+==== objektorientierter Entwurf (OOD) ====
+(objektorientiertes Design)
+Im Vordergrund steht die Festlegung der [[#Klasse]]n,
+die zur Lösung der Aufgabe erforderlich sind.
+Klassen werden mit möglichst eng definierten Aufgaben versehen.
+Größere Aufgaben werden durch Kooperation ([[#Kollaborationsdiagramm]])
+von [[#Objekt]]en
+gelöst. Dabei treten wiederkehrende Teilaufgaben auf,
+für die bereits Lösungen bekannt sind ([[#Entwurfsmuster]]).
+==== objektorientiertes Programmieren (OOP) ====
+Philosophie des Programmierens, die von einer Welt ausgeht,
+die aus gleichberechtigten und einheitlich erscheinenden [[#Objekt]]en
+besteht.
+Objekte erledigen Aufgaben prinzipiell in eigener Verantwortung.
+Um die Fähigkeiten anderer Objekte nutzen zu können,
+schicken sich die Objekte [[#Botschaft]]en.
+==== One definition rule ====
+Die Definition einer Funktion oder einer
+[[#global]]en Variable darf nur genau einmal im gesamten Programm erfolgen.
+Übertretugnen dieser Regel führen zu Fehlern beim [[#Binden]]
+(mehrfach definierte oder fehlende Symbole).
+==== Operator ====
+vordefiniertes Zeichen oder Zeichengruppe,
+deren Anwendung auf einen [[#Ausdruck]]
+oder mehrere Ausdrücke
+zu einer auswertenden Handlung führt,
+in deren Ergebnis ein Ergebniswert steht.
+Operatoren können einen [[#Seiteneffekt]]
+produzieren.
+Je nach Anzahl der benötigten Operanden
+heißen Operatoren einstellig (unär),
+zweistellig (binär) oder dreistellig (ternär).
+Für einen benutzerdefinierten [[#Typ]]
+([[#Klasse]], [[#Struktur]])
+lassen sich die (meisten) Operatoren [[#Überladen|überladen]].
+===== P =====
+==== Parameter ====
+im [[#Funktionskopf]]
+hinter dem Funktionen aufgelistete lokale Variablen,
+die als Platzhalter für die beim [[#Funktionsaufruf]]
+zu übernehmenden [[#Argument]]e
+dienen.
+Die Parameter übernehmen eine Kopie des Argumentwertes,
+der im Inneren der Funktion beliebig verändert werden kann,
+ohne dass dies sich auf das aufrufende Argument auswirkt
+(Kopierverhalten, Wertsemantik).
+Wertparameter bilden eine "Einbahnstraße" für den Datenfluss.
+Wird der Typ des Parameters durch ein nachfolgendes ''&''
+gekennzeichnet, handelt es sich um einen Referenzparameter.
+Eine solche Referenz wird mit dem typgleichen Speicherplatz
+der Argumentvariable gleichgesetzt.
+Änderungen an dieser Variable wirken sich direkt auf das aufrufende Argument aus.
+(Referenzverhalten).
+Ein [[#Feld]]
+als Funktionsparameter wird nicht kopiert,
+sondern mit dem Feldnamen nur als Zeiger auf die Anfangsadresse des Argumentfeldes
+an die Funktion übergeben. Da auch bei Feldern direkt auf dem Speicher
+des Argumentes gearbeitet wird, haben auch Feldparameter Referenzverhalten.
+==== Parameter pack ====
+durch ''%%...%%'' kenntlich gemachte unbestimmte Anzahl von [[#Schablone]]n[[#parameter]]n, ab [[#C++11]].
+==== PASCAL ====
+(benannt nach dem Mathematiker Blaise Pascal)
+von Niklaus Wirth entworfene Programmiersprache
+als Ableger der (immer komplizierter werdenden) Sprache ALGOL.
+Die Sprache entstand mit dem Ziel einer
+einfach erlernbaren Quelltextstruktur
+und strenger Typprüfung.
+Erfolgreiche Weiterentwicklungen sind Modula, Oberon und Delphi.
+==== Persistenz ====
+Daten überleben das Programm.
+Daten existeren zwischen Programmausführungen,
+sogar verschiedenen Versionen eines Programms weiter.
+==== POD ====
+(engl. plain old data structure)
+[[#Struktur]] oder [[#Klasse]] ohne nutzerdefinierte [[#Konstruktor]]en, [[#Destruktor]] und ohne [[#virtuelle Methode]]n.
+==== Polymorphie ====
+(grch. Vielgestaltigkeit)
+Gleichlautende Botschaften an Objekte verwandter, [[#abgeleitete Klasse|abgeleiteter Klassen]]
+bewirken unterschiedliches Verhalten.
+Objekte abgeleiteter Klassen können dort eingesetzt werden,
+wo [[#Zeiger]]
+oder [[#Referenz]]en
+auf Objekte der [[#Basisklasse]]
+erwartet werden.
+Für bestimmte, in der Basisklasse als virtuell markierte [[#Methode]]n
+wird das [[#Binden]]
+des Methodenrumpfes nicht beim Übersetzen (frühe Bindung) durchgeführt,
+sondern bis zum Methodenaufruf
+verzögert (späte Bindung). Die Zuordnung der richtigen (virtual = tatsächlichen) Methode
+erfolgt über eine im Objekt versteckt mitgeführte, sog. virtuelle Methodentabelle.
+Neben dieser dynamischen Polymorphie gibt es in C++
+auch statische oder Typ-Polymorphie.
+Es können gleichnamige [[#Funktion]]en
+mit unterschiedlichen Parameterlisten überladen werden.
+Beim [[#Funktionsaufruf]]
+wird anhand der übergebenen Argumenttypen entschieden,
+welche Funktion aufgerufen werden soll.
+[[#Schablone]]n
+verallgemeinern dieses Überladen auf beliebige Argumenttypen.
+==== Prädikat ====
+[[#Funktion]] mit booleschem [[#Rückgabetyp]]
+==== Präprozessor ====
+Entwicklungswerkzeug zum Einbinden von Dateien
+und zum Textersatz ([[#Makro]]s)
+während des Übersetzungsvorgangs.
+==== Priorität ====
+([[#Rangfolge]])
+==== Programmierstil ====
+Herangehensweise und Auswahl der Sprachmittel für die Programmentwicklung:
+  * ** strukturiertes Programmieren **: Einsatz von [[#Verzweigung]]en und [[#Schleife]]n  zur Ablaufsteuerung
+  * ** funktionales Programmieren **: [[#Funktion]]en übernehmen unveränderliche [[#Variable]]n als Platzhalter für Werte, die mit [[#Operator]]en verknüpft und an Funktionen übergeben und von diesen zurückgegeben werden. Selbstaufrufe (Rekursion) werden anstelle von Schleifen eingesetzt.
+  * ** prozedurales Programmieren **: Definition und Aufruf von [[#Prozedur]]en mit [[#Parameter]]n
+  * ** modulares Programmieren **: Aufteilung des Quelltextes in inhaltlich zusammengehörende Abschnitte ([[#Modul]]e)
+  * ** objektbasiertes Programmieren  **: Verwendung und evtl. auch Definition von [[#Klasse]]n
+  * ** objektorientiertes Programmieren **: Einsatz von [[#Vererbung]] und [[#Polymorphie]]
+  * ** generisches Programmieren ** : Entwurf von typunabhängigen, typparametrisierten Funktionen und Klassen ([[#Schablone]]n)
+C++ ist eine Hybridsprache.
+Sie erlaubt den Einsatz einer Reihe unterschiedlicher Programmierstile,
+diese können auch gemischt eingesetzt werden.
+In den Augen eines Theoretikers ist dies ein Makel:
+C++ ist unrein.
+Einem Praktiker geht es jedoch nicht um das Prinzip der reinen Lehre:
+er muss praktische Probleme lösen,
+deren Vielfalt und Komplexität unterschiedliche Herangehensweisen erforderlich machen;
+ein ständiger Wechsel zwischen "reinen" Plattformen bringt mehr Probleme als er aus der Welt schafft.
+==== Prozedur ====
+(engl. void function, subroutine, procedure, Unterprogramm)
+Programmteil, der eine Folge von [[#Anweisung]]en
+unter einem Namen ([[#Bezeichner]]) zusammenfasst.
+Im Gegensatz zu einer [[#Funktion]]
+liefert eine Prozedur kein Ergebnis.
+Es kommt hier nur auf den Seiteneffekt an.
+C und C++ unterscheiden in ihrer [[#Grammatik]]
+nicht zwischen Funktionen und Prozeduren.
+Beide werden unter der Bezeichnung Funktion zusammengefasst.
+Eine Prozedur ist eine Funktion mit dem [[#Rückgabetyp]]
+''void'', die nichts (engl. void = leer) zurückliefert.
+===== Q =====
+==== Quelltext ====
+(engl. source code)
+in einer Programmiersprache geschriebenes Programmtext,
+das einem [[#Compiler]]
+oder Interpreter übergeben wird.
+===== R =====
+==== RAII-Prinzip ====
+(engl. resource acquisition is initialisation),
+auch [[#AC/DC]]-Prinzip.
+Besitzübernahme an angeforderten Ressourcen (Speicher, Dateien) durch [[#Konstruktor]]en stellt sicher,
+dass Ressourcen durch den [[#Destruktor]] automatisch freigegeben werden.
+==== Rangfolge ====
+(Priorität)
+legt fest, in welcher Reihenfolge unterschiedliche [[#Operator]]en
+in einem mehrgliedrigen Ausdruck ausgewertet werden.
+Bei gleicher Rangstufe muss auch die Bindungsrichtung der Operatoren beachtet werden.
+Damit liegt in C und C++ aber immer noch nicht fest,
+in welcher Reihenfolge Teilausdrücke und nebeneinander stehende [[#Funktionsaufruf]]e
+als Operanden ausgewertet werden.
+Haben die Funktionen sich [[#Seiteneffekt]]e,
+die sich gegenseitig beeinflussen,
+ist die Wirkung implementationsabhängig.
+==== Referenz ====
+(engl. reference, Alias, Verweis)
+[[#Typ]],
+der einen [[#Bezeichner]]
+mit einem schon existierenden Objekt dauerhaft verbindet.
+==== Rückgabetyp ====
+[[#Typ]]
+für den von einer [[#Funktion]]
+zurückgelieferten Wert.
+==== Rule of Five ====
+Verschiebekonstruktor und Verschiebezuweisung erweitern seit [[#C++11]] die [[#Rule_of_three|Regel der großen Drei]].
+Sie erlauben dem Nutzer, verwaltete Ressourcen leicht in andere Objekte zu übertragen.
+Compiler folgen [[..:kennen:spezielle_methoden#Regeln]] für das automatische Erzeugen bzw. Weglassen dieser [[..:kennen:spezielle_methoden|speziellen Methoden]].
+Die Kapselung der Ressourcenverwaltung in solchen Klassen erlaubt diese Nutzern, der [[#Rule_Of_Zero|Rule of Zero]] zu folgen.
+==== Rule of Three ====
+Regel der großen Drei (Destruktor, Kopierkonstruktor, Zuweisungsoperator):
+Wird eine dieser Methoden einer Klasse vom Programmierer definiert,
+so müssen meist auch die anderen beiden definiert oder verboten werden
+(Ausnahme: trivialer virtueller Destruktor einer [[#Basisklasse]]).
+Mit der ab [[#C++11]] vorhandenen [[#Verschiebesemantik]]
+wird dies zur Regel der großen Fünf ([[#rule_of_five|Rule of Five]]).
+==== Rule of Zero ====
+Gute Programmierpraxis kapselt die Ressourcenverwaltung in [[#Attribut]]-Variablen.
+So definierte Klassen müssen gar keine [[..:kennen:spezielle_methoden|speziellen Methoden]] deklarieren.
+Sie werden automatisch definiert, sofern die Bestandteile der Klasse Kopier- bzw. Verschiebeverhalten erlauben.
+==== rvalue ====
+(engl. right-hand side value)
+[[begriffe#Ausdruck]], der auf der rechten Seite einer Zuweisung stehen darf.
+==== Rvalue-Referenz ====
+''T&&'' ... Verweis auf einen [[#rvalue]], der [[#Verschiebesemantik]] erlaubt. Für Funktionsparameter dieser Art wurde die Bezeichnung "weiterleitende Referenz" (forwarding reference) eingeführt.
+==== RVO ====
+(engl. return value optimization)
+vermeidet unnötige Kopie des Rückgabewertes einer [[#Funktion]].
+===== S =====
+==== Schablone ====
+(engl. template, Vorlage)
+allgemeingültige (generische) [[#Funktion]]
+oder [[#Klasse]],
+bei deren [[#Definition]]
+ein oder mehrere [[#Typ]]en
+und / oder ganzzahlige [[#Konstante]]n
+bewusst nicht festgelegt werden.
+Die Festlegung dieser Schablonen-[[#Parameter]]
+erfolgt bei Bedarf durch Spezialisierung beim Übersetzen
+eines [[#Funktionsaufruf]]s
+bzw. Bildung einer konkreten Klasse.
+==== Schleife ====
+(engl. loop, wiederholte Anweisung)
+[[#Steueranweisung]]
+zur wiederholten Ausführung einer [[#Anweisung]]
+oder eines Anweisungsblocks (Schleifenrumpf).
+Je nach Reihenfolge von [[#Block]]
+und Ausführungs-[[#Bedingung]]
+werden Schleifen als [[#kopfgesteuerte Schleife|kopfgesteuert]]
+bzw. [[#fußgesteuerte Schleife|fußgesteuert]]
+bezeichnet.
+Ist die Testbedingung stets erfüllt,
+liegt eine Endlosschleife vor.
+==== Schlüsselwort ====
+(engl. keyword)
+reservierter Bezeichner mit besonderer,
+in der Programmiersprache festgelegter Bedeutung.
+==== Schnittstelle ====
+(engl. interface)
+Zusammenfassung aller von außen benötigten
+und aller von außen abrufbaren Größen,
+umfasst Vereinbarungen über die Art und Weise,
+wie Informationen ausgetauscht werden,
+ermöglicht die unabhängige Implementierung von Programmteilen
+([[#Modul]]en),
+erleichtert Benutzung und Fehlersuche.
+Die Schnittstelle einer [[#Funktion]]
+ist ihr Funktionskopf.
+Die Schnittstelle einer [[#Klasse]]
+umfasst alle [[#Zugriffsrecht|öffentlich zugänglichen]] Bestandteile
+([[#Attribut]]e
+und [[#Methode]]n).
+==== Seiteneffekt ====
+Einige [[#Operator]]en
+lesen die Werte ihrer Operanden nicht nur aus.
+Sie verändern diese auch, bewirken Ausgaben in einen Datenstrom,
+fordern Ressourcen an oder geben diese frei.
+Diese Wirkungen sind Seiteneffekte der Auswertung.
+Auch [[#Funktion]]en und [[#Methode]]n
+können neben der Auswertung der [[#Parameter]]
+und der Rückgabe eines Ergebnisses
+globale Variablen oder Objektzustände ändern.
+Der Seiteneffekt einer [[#Zuweisung]]
+''x=3;'' ist ausdrücklich erwünscht.
+Da die Auswertungsreihenfolge von gleichrangigen Operanden
+innerhalb einer Anweisung implementationsabhängig ist,
+sollten mehrere, sich beeinflussende Seiteneffekte
+vermieden werden:
+<code cpp>
+int a = 1;
+int b = a++ + a--; // Welchen Wert hat b? 1, 2 oder 3 ?
+</code>
+==== SFINAE ====
+(engl. spezialization failure is not an error)
+Tritt bei der [[#Spezialisierung]] einer [[#Schablone]] ein Übersetzungsfehler auf, wird diese ohne Fehlermeldung aus der Liste möglicher Kandidaten entfernt. Ein [[#TMP]]-Trick.
+==== SIMULA ====
+(SIMULAtion language)
+von Ole-Johan Dahl und Kristian Nygaard 1965-1967 entworfene
+Programmiersprache für ereignisgesteuerte Simulationen,
+Ableger von ALGOL, mit Objektkonzept und Koroutinen.
+==== Sequenzdiagramm ====
+grafische, zeitbasierte Darstellung von [[#Botschaft]]en
+mit vertikaler Zeitachse,
+siehe auch: [[#Kollaborationsdiagramm]].
+==== SmallTalk ====
+objektorientierte Programmiersprache und Programmierumgebung,
+/1980 im XEROX PARC entwickelt.
+==== Software ====
+Gesamtheit aller zur Steuerung einer Datenverarbeitungsanlage ([[#Computer]]) notwendingen Programme und Daten.
+==== Software-Engineering ====
+(dt. Softwaretechnik)
+Ingenieurdisziplin, die sich mit planvollem Entwurf, Entwicklung und Organisation von [[#Software]]-Systemen befasst.
+==== Speicherbereinigung ====
+(engl. garbage collection)
+Mechanismus in der Laufzeitumgebung (objektorientierter) Softwaresysteme,
+mit dem der Speicherbereich nicht mehr benutzter [[#Objekt]]e
+wieder bereitgestellt wird,
+entbindet Programmierer von der Pflicht,
+dynamisch angeforderten Speicher nach der Nutzung manuell freizugeben.
+C++ enthält keinen "Müllsammler",
+allerdings können solche über [[#Bibliothek]]en
+eingebunden werden.
+==== Speicherklasse ====
+(engl. storage class)
+legt Lebensdauer [[#lokal]]er
+Variablen (automatisch, statisch oder Register)
+bzw. die Bindung (Sichtbarkeit) [[#global]]er
+Bezeichner (statisch oder extern) fest.
+==== Spezialisierung ====
+taxonomische [[#Beziehung]]
+zwischen einer allgemeinen und der speziellen Einheit,
+wobei das speziellere weitere Eigenschaften ([[#Attribut]]e)
+hinzufügt, die Semantik erweitert und sich kompatibel zum allgemeinen verhält.
+==== Sprung ====
+(engl. jump)
+Anweisung, das Programm an anderer Stelle fortzusetzen.
+In C ist der Sprung auf das Innere einer [[#Funktionsrumpf]]es
+beschränkt.
+==== Standardkonstruktor ====
+[[#Konstruktor]], erstellt ein [[#Objekt]]
+ohne Angabe von [[#Parameter]]n.
+==== Steueranweisung ====
+[[#Verzweigung]]en
+und [[#Schleife]]n
+gestatten Abweichungen von der sequentiellen Abarbeitung von [[#Anweisung]]en.
+==== STL ====
+(engl. standard template library)
+ursprünglich von [[wp>Alexander Stepanov]] und Meng Lee vorgeschlagene [[#Schablone]]n[[#bibliothek]]
+für [[#Algorithmus|Algorithmen]] und [[#Container]],
+die in [[#C++98]] eingeflossen ist.
+Auch:[[https://nuwen.net/stl.html|Stephan T. Lavavej]], Microsofts Betreuer der C++-Bibliothek des Visual Studio C++ Compilers.
+==== Structured Bindings ====
+seit [[#C++17]]: Definition mehrerer Variablen aus den Bestandteilen von [[#Struktur]], [[#Feld]] o.ä.
+==== Struktur ====
+(engl. structure, record, Datenverbund)
+benutzerdefinierter [[#Typ]],
+der mehrere [[#Komponente]]n
+als Einheit zusammenfasst.
+==== Syntax ====
+([[#Grammatik]])
+==== Szenario ====
+bestimmte Folge von Aktionen, z.B. ein konkreter Ablaufpfad in einem [[#Anwendungsfall]],
+siehe [[#Sequenzdiagramm]].
+===== T =====
+==== TMP ====
+(engl. template meta programming)
+nutzt die Auswertung von [[#Schablonen]] durch den [[#Compiler]] zur Berechnung.
+==== Typ ====
+Festlegung von Speicherplatzbedarf,
+Wertebereich und Operationen,
+wird bei der Übersetzung überprüft und [[#Variable]]n
+zugeordnet.
+Neben einfachen Grunddatentypen und in Bibliotheken vordefinierten Typen
+können vom Programmierer eigene Typen festgelegt und benutzt werden.
+[[#Struktur]]en
+und [[#Klasse]]n
+sind zusammengesetzte Typen.
+==== Typecast ====
+zwangsweise Uminterpretation des Speicherabbildes einer Variable,
+setzt die [[#Typ]]-Prüfung des [[#Compiler]]s
+außer Kraft.
+Die Verantwortung für die Sinnhaftigkeit muss der Programmierer übernehmen.
+==== Typumwandlung ====
+(engl. type conversion)
+im stillen vollzogene (implizite)
+oder ausdrücklich angeforderte (explizite)
+Umwandlung eines Wertes in einen anderen [[#Typ]].
+Grunddatentypen sind in einem großen Maße ineinander wandelbar.
+Passt der Wert nicht in den Wertebereich des Zieltyps,
+kann das zu Datenverlust (Zahl signifikanter Stellen) führen.
+Dabei vom [[#Compiler]]
+ausgebene Warnungen können durch
+ausdrückliche Umwandlungsanweisung unterbunden werden.
+Ist keine Umwandlung möglich, wird vom Compiler ein Fehler gemeldet.
+Ein [[#Typecast]]
+setzt auch solche Fehlermeldungen außer Kraft.
+Klassen können die bei Typumwandlung vorzunehmenden Aktionen
+durch einstellige [[#Konstruktor]]en
+und durch Typumwandlungs-[[#Operator]]en
+festlegen.
+===== U =====
+==== Überladen ====
+(engl. overload)
+belegt einen [[#Bezeichner]]
+einer [[#Funktion]]
+oder einen [[#Operator]]
+mit einer neuen Bedeutung in einem anderen Zusammenhang.
+Die mehrfache Verwendung desselben Funktionsnamens oder eines Operators
+mit unterschiedlicher Parameterliste oder [[#Parameter]]n
+unterschiedlicher Typen erlaubt statische [[#Polymorphie]].
+==== Überlauf ====
+(engl. overflow, underflow)
+Übertreten einer Wertebereichsgrenze.
+Bei Ganzzahlen wird in C++ am anderen Ende des Wertebereichs weitergezählt
+(Zahlenring, Modulo-Arithmetik), ohne dass ein Fehler gemeldet wird.
+Fließkommazahlen gehen (bei heute üblichen Implementierungen) "weich" zu 0 über,
+zu große Werte können als "unendlich" dargestellt werden.
+==== Überschreiben von Methoden ====
+(engl. redefinition, overriding)
+Eine [[#abgeleitete Klasse]]
+definiert eine geerbte [[#Methode]]
+der [[#Basisklasse]]
+unter dem gleichen Namen neu.
+Anzahl und Typen der Parameter müssen gleich bleiben,
+sonst wird die Methode [[#Überladen von Methoden|überladen]].
+==== Übersetzungseinheit ====
+Eine Quelltextdatei, die getrennt von anderen übersetzt wird (siehe auch [[#Modul]]).
+==== UML ====
+(engl. Unified Method Language)
+graphische Notation für objektorientierte Softwareentwürfe, u.a.
+  * [[#Klassendiagramm]],
+  * [[#Objektdiagramm]],
+  * [[#Kollaborationsdiagramm]],
+  * [[#Sequenzdiagramm]],
+  * [[#Zustandsdiagramm]].
+==== uniform initialization ====
+Seit [[#C++11]]: Angabe von Anfangswerten in geschweiften Klammern. Erlaubt keine implizite Konversion in "schmalere Datentypen" (narrowing).
+Ein [[#Konstruktor]] mit runden Klammern ist vom evtl. definierten Konstruktor mit ''std::initializer_list'' zu unterscheiden.
+<code cpp>
+int x { 3 };             // int x = 3;
+int y {};                // int y = 0; auch für lokale Variable
+std::vector<int> v{4,5}; // Liste von 2 Ganzzahlen mit den Werten 4 und 5
+// aber:
+std::vector<int> v(4,5); // 4 Ganzzahlen mit Wert 5
+</code>
+==== Unterklasse ====
+([[#abgeleitete Klasse]])
+===== V =====
+==== Variable ====
+benannter Speicherplatz, der über einen [[#Bezeichner]]
+angesprochen wird und einen Wert von einem bestimmten [[#Typ]]
+aufnimmt.
+Durch Operationen wie [[#Zuweisung]]
+oder Einlesen aus einem Datenstrom
+kann der Wert der Variable verändert werden.
+Bei bekannter Speicheradresse kann der Wert auch indirekt über [[#Zeiger]]
+manipuliert werden.
+[[#Lebensdauer]], [[#Geltungsbereich]]
+und [[#Zugriffsrecht]]
+hängen von der Art und Lage der [[#Definition]]
+ab.
+==== Verallgemeinerung ====
+(Generalisierung, [[#Abstraktion]])
+geistiges Verfahren zur Zusammenfassung gemeinsamer Eigenschaften
+einer Gruppe von [[#Klasse]]n
+als [[#Basisklasse]].
+==== Verantwortlichkeit ====
+(engl. responsibility, Zuständigkeit)
+umfasst die [[#Attribut]]e
+und die interpretierbaren [[#Botschaft]]en
+eines [[#Objekt]]s.
+==== Vereinigung ====
+benutzerdefinierter zusammengesetzter [[#Typ]],
+dessen [[#Komponente]]n
+denselben Speicherplatz überdecken.
+==== Vererbung ====
+(engl. inheritance, Typerweiterung, Ableitung)
+programmiersprachliches Konzept für die Umsetzung einer Beziehung
+zwischen einer [[#Basisklasse]]
+und einer [[#abgeleitete Klasse|abgeleiteten Klasse]],
+wodurch die abgeleiteten Klassen die Eigenschaften der Basisklassen
+mitnutzen können.
+Die Vererbung implementiert normalerweise bestimmte
+Generalisierungs- und Spezialisierungsbeziehungen von Objekttypen,
+meist im Zusammenhang mit [[#Polymorphie]].
+==== Vererbungshierarchie ====
+(Klassenhierarchie)
+Geflecht der [[#Vererbung]]sbeziehungen in einem objektorietierten System,
+bei [[#Einfachvererbung]]
+ein Baum oder Wald,
+bei [[#Mehrfachvererbung]]
+ein gerichteter, azyklischer Graph.
+==== Verhalten ====
+beobachtbare Effekte aller Operationen, die auf das [[#Objekt]]
+angewendet werden können.
+Wie das Objekt agiert und reagiert, wie sich sein [[#Zustand]]
+ändert, ist vollständig durch seine Operationen festgelegt.
+==== Verschiebekonstruktor ====
+(engl. move constructor)
+erzeugt ein [[#Objekt]] mit den [[#Attribut]]werten einer [[#rvalue-Referenz]].
+Das neue Objekt übernimmt den Besitz an den Ressourcen und hinterlässt diese als leere Hülle ([[#Verschiebesemantik]]).
+==== Verschiebesemantik ====
+Besitzübernahme durch [[#Verschiebekonstruktor]]en und Verschiebezuweisung.
+Die übernommene [[#Rvalue-Referenz]] ist danach nicht mehr im Besitz der von ihr verwalteten Ressourcen.
+==== Verzweigung ====
+(Auswahl, Entscheidung)
+Steueranweisung, die anhand einer [[#Bedingung]]
+entscheidet, welche von zwei oder mehreren [[#Anweisung]]en
+bzw. Anweisungsfolgen ausgeführt werden muss.
+==== virtuelle Basis ====
+(engl. virtual base class)
+Bei der [[#Vererbung]]
+über mehrere Vererbungspfade (Rhombusmuster bei [[#Mehrfachvererbung]])
+wird nur ein gemeinsames Basisklassenobjekt angelegt.
+==== virtuelle Methode ====
+(engl. virtual member function, polymorphe Methode)
+realisiert dynamische [[#Polymorphie]].
+Erst zur Laufzeit wird bestimmt, welche Operation ausgeführt wird
+(dynamische, späte [[#Bindung]]).
+==== Vorbedingung ====
+[[#Zustand]],
+der vor dem Ablauf einer Operation gegeben sein muss ([[#Zusicherung]]).
+===== W =====
+==== Wertebereich ====
+Menge der möglichen Datenwerte eines [[#Typ]]s.
+==== Wiederverwendbarkeit ====
+(engl. reusability)
+Entwurfziel zur Erhöhung der Produktivität beim Softwareentwurf.
+===== X =====
+===== Y =====
+===== Z =====
+==== Zeiger ====
+(engl. pointer)
+[[#Typ]],
+dessen Objektwerte Speicheradressen von (anderen) Objekten sind.
+Über Zeiger sind zeitweilige Verweise
+und Zugriffe auf Daten ([[#Variable]]n, [[#Objekt]]e) im Hauptspeicher möglich.
+Zeiger sind an einen Typ gebunden,
+der zu den verwiesenen Daten passen muss.
+==== Zeigerarithmetik ====
+Rechenregeln für den Umgang mit [[#Zeiger]]n
+in zusammenhängenden Speicherbereichen ([[#Feld]]ern).
+==== Zugriffsrecht ====
+(engl. granted access)
+von [[#Klasse]]n
+und [[#Struktur]]en
+zu verleihende Erlaubnis, [[#Komponente]]n
+und [[#Methode]]n
+in einem [[#Ausdruck]]
+zu benutzen.
+C++ hat ein dreistufiges System der Rechtevergabe
+(öffentlich, geschützt und privat),
+welches noch durch ausdrücklich ausgewiesene Freunde ergänzt wird.
+==== Zusicherung ====
+(engl. assertion, Behauptung)
+[[#Bedingung]]en
+für einen korrekten Ablauf einer [[#Anweisung]]
+oder Anweisungsfolge.
+[[#Vorbedingung]]en
+sollen prüfen, ob die Eingangsgrößen zulässige Werte enthalten,
+die Voraussetzung für den korrekten Ablauf eines [[#Algorithmus]]
+sind.
+Nachbedingungen sollen sicherstellen,
+dass die Ergebnisse im erwarteten Bereich liegen.
+Korrektheitsbeweise können nicht erbracht werden,
+dennoch sind Zusicherungen ein wesentliches Hilfsmittel
+zur frühzeitigen Erkennung von Fehlern (design by contract).
+Bei nicht erfüllter Zusicherung kann das Programm mit einer
+Fehlermeldung beendet oder eine [[#Ausnahme]]
+geworfen werden.
+==== Zustand ====
+(engl. state)
+wird bestimmt durch die [[#Attribut]]werte des [[#Objekt]]es
+und seine Verbindungen zu anderen Objekten,
+die zu einem bestimmten Zeitpunkt existieren.
+==== Zustandsdiagramm ====
+(engl. state transition diagram)
+grafische Darstellungsform eines Zustandsautomaten.
+==== Zuweisung ====
+(engl. assignment)
+Ausdruck, der einer Variable (allgemeiner einem [[#lvalue]])
+einen neuen Wert zuweist.
+===== Quellen =====
+  - Balzert, Helmut: Lehrbuch der Software-Technik. Spektrum, Heidelberg (2000).
+  - Booch, Grady: Object Oriented Design with Applications. Benjamin Cummings, Redwood (1991).
+  - Herkunftswörterbuch. Bertelsmann, Gütersloh (1998).
+  - Informatik-Duden. Dudenverlag, Mannheim (1993).
+  - McGregor, John D.; Sykes, David A.: Object-Oriented Software Development: Engineering Software for Reuse. Van Nostrand Reinhold, New York (1992).
+  - Oesterreich, Bernd: Objektorientierte Software-Entwicklung. Oldenbourg, München (1998).
+  - Rechenberg, Peter; Pomberger, Gustav: Informatik-Handbuch. Hanser, München (1999).
+  - Stroustrup, Bjarne:  Die C++ Programmiersprache. 3. Aufl. Addison-Wesley, Bonn (1998).
+  - [[http://en.cppreference.com/w/]]