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]

(engl. derived class, sub class, Kind, Erbe, Unterklasse)

durch Vererbung aus einer Basisklasse hergeleiteter benutzerdefinierter Typ.

enthält mindestens eine abstrakte Methode, spielt eine wichtige Rolle in Vererbungsbeziehungen, wo sie Gemeinsamkeiten einer Gruppe von Unterklassen definiert. Sie kann keine Objekte bilden. Zuvor muss eine Klasse abgeleitet werden, die die bisher abstrakten Methoden redefiniert.

ist bewusst unvollständig, hat keine Implementation, ihr Methodenrumpf fehlt. Sie ist in abgeleiteten Klasse zu überschreiben.

(von lat. abstrahere = wegziehen)

geistige Tätigkeit, um unter einem bestimmten Gesichtspunkt wesentliche Merkmale eines Begriffes herauszusondern.

(acquisition in constructor, destructor cleans up), siehe RAII-Prinzip.

(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.

Sonderform der Assoziation, in der die beteiligten Klassen eine Teil-Ganzes-Hierarchie darstellen. Die Teile sind existenzunabhängig von Ganzen.

(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.

Einleitung der Variablendefinition mit dem Schlüsselwort auto (ab C++11). Dieser Schreibstil hat den Vorzug, dass eine Anfangswertbelegung der Variable zwingend erforderlich ist.

durch eine Botschaft ausgelöste Operation (Aufruf einer Methode).

(engl. statement)

Definition für den Compiler oder zur Laufzeit auszuführender Befehl.

(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.

(engl. application framework)

Menge von zusammenarbeitenden Klassen, die einen wiederverwendbaren Entwurf für einen bestimmten Anwendungsbereich implementieren, besteht aus konkreten und insbesondere abstrakte Klassen, die Schnittstellen definieren. Im allgemeinen wird vom Programmierer erwartet, dass er abgeleitete Klassen definiert, um das Rahmenwerk zu verwenden und anzupassen.

(seltener: aktueller Parameter)

Wert, Variable oder Ausdruck, der / die beim Funktionsaufruf an die Stelle eines formalen Parameters gesetzt wird.

modelliert Verbindungen zwischen Objekten einer oder mehrerer Klassen, wird beschrieben durch Assoziations- oder Rollennamen und Kardinalitäten. Sonderfälle: Aggregation, Komposition.

Modellelement, das über Eigenschaften einer Klasse und einer Assoziation verfügt.

OOP: (engl. member data, member variable) Variable als Datenbestandteil einer Struktur oder Klasse.

C++11: Attributspezifizierer verstecken compilerspezifische Spracherweiterungen hinter doppelten eckigen Klammern [[ ]].

aktuell einem Attribut zugeordneter Wert.

(engl. expression)

ein oder konstanter Wert, Variablenname, Funktionsaufruf oder mehrere, durch geeignete Operatoren 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

(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.

(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.

(engl. base class, super class, Elter, Vorfahr, Oberklasse)

Klasse, von der durch Vererbung verwandte, d.h. ähnliche, modifizierte Typen abgeleitet werden.

(Basic Combined Programming Language)

von Martin Richards entworfene Programmiersprache, bildete den Ausgangspunkt für die Entwicklung der Programmiersprache C.

ein Testausdruck, der bestimmt, ob eine Anweisung oder Anweisungsfolge überhaupt (Entscheidung, Verzweigung) oder wiederholt (Schleife) ausgeführt werden muss.

(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.

(engl. identifier, Name)

Folge von Buchstaben, Zifferzeichen oder Unterstrichen zur eindeutigen Benennung von Typen, Variablen, Funktionen oder Namensräumen.

(engl. relationship)

Verbindung zwischen Modellelementen mit semantischem Gehalt, Oberbegriff für Instanzbeziehung, Assoziation, Aggregation, Komposition, Verallgemeinerung und Spezialisierung.

(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 (Modulen) in Bibliotheken erfolgt meist mit einem speziellen Programm, Bibliothekar / Archivar (in UNIX: ar) genannt

(engl. to link, Linker)

Vorgang, bei dem (getrennt) übersetzte Programmteile (Module) und Bibliotheken zum lauffähigen Programm verbunden werden.

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 polymorphen Objekten erst zur Laufzeit beim Aufruf der virtuellen Methode.

Software-Engineering: beschreibt die Stärke der Abhängigkeiten (Kopplung) von Funktionen innerhalb eines Moduls.

(engl. bit field structure)

zusammengesetzter Typ, dessen einzelne Komponenten 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.

von einem Paar geschweifter Klammern { } eingeschlossene Folge von Anweisungen. Anweisungsblöcke sind ineinander schachtelbar.

Der C-Block-Kommentar /* Kommentar */ ist dagegen nicht schachtelbar.

(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.

ISO-Standard 14882:1998 Programmiersprache C++, erster Sprachstandard.

ISO-Standard 14882:2003 Programmiersprache C++, blieb bis auf kleine Korrekturen unverändert.

ISO-Standard 14882:2011 Programmiersprache C++, umfangreiche Erweiterung. Die vormalige vorläufige Benennung C++0x wurde zum Insiderwitz: x=0xB

ISO-Standard 14882:2014 Programmiersprache C++, kleinere Ergänzungen.

ISO-Standard 14882:2017 Programmiersprache C++, bedeutende Ergänzungen in Sprache und Bibliothek.

ISO-Standard 14882:2020 Programmiersprache C++. Vorläufige Bezeichnung war C++2a.

Abkürzung für den Sprachstandard 2023. Vorläufige, inoffizielle Abkürzung war C++2b.

Der nächste Standard wird für 2026 erwartet. In Arbeit.

Einschluss der in der lokalen Umgebung definierten, in einem Lambda-Ausdruck genutzten Werte oder Referenzen.

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.

(engl. Rechner, ehemals auch Mensch, der Rechenaufgaben bearbeitet)

elektronische Datenverarbeitungsanlage, besteht aus Hardware und Software.

ab C++20

benannte Anforderung an Schablonen, bei der Übersetzung vom Compiler ausgewertetes Prädikat

Datenbehälter, in C++ typunabhängige Schablonen-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 Algorithmen abgestimmt.

(engl. class, responsibilities, collaborations; Klassenkarten)

Karteikarten, auf denen der Name der Klasse, ihre Aufgaben (Verantwortlichkeiten) und ihre Beziehungen beschrieben werden.

(engl. constructor template argument deduction), ab C++17

Herleitung von Schablonen-Typ-Parametern aus den Argumenten eines Konstruktors.

Hilfsanweisungen für den Compiler, wie der Typ einer Schablone aus den Konstruktor-Argumenten hergeleitet werden soll.

(Kapselung)

Prinzip, nur die auf ein Objekt anwendbaren Operationen nach außen sichtbar zu machen.

Festlegung eines Typs, einer Variable, eines Funktionsrumpfes. Jede Definition ist zugleich eine Deklaration. Die Definition eines Bezeichners darf nur genau einmal erfolgen (one definition rule).

Anmeldung eines Namens (Bezeichner) für eine Typ, eine Variable oder eine Funktion durch Angabe des Funktionskopfes. 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.

Objekt leitet Botschaft an ein anderes Objekt weiter (Kollaboration).

Methode, die (automatisch) beim Zerstören eines Objektes ausgeführt wird, soll u.a. dynamisch belegte Ressourcen (z.B. Speicher) freigeben,die während der Lebensdauer im Besitz des Objektes waren.

(engl. single inheritance)

Jede Klasse besitzt maximal eine direkte Basisklasse. Es entsteht eine Baumstruktur (Vererbungshierarchie).

Bestandteil einer Folge, z.B. einem Feld oder Datenwert in einem Container.

(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.

(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.

Einsatz der Vererbungstechnik zur Wiederverwendung von Code. Eine "ist implementiert mit Hilfe von"-Beziehung kann auch durch eine Komposition realisiert werden.

Einsatz der Vererbungstechnik, um gemeinsame Schnittstellen (Oberbegriffe) für eine Hierarchie von abgeleiteten Klassen festzulegen, deren Verhalten durch Überschreiben ihrer virtuellen Methoden und Polymorphie angepasst wird.

Herauslösen und Zusammenfassen der Gemeinsamkeiten verwandter Klassen zu einer gemeinsamen Basisklasse.

(engl. fold expression), ab C++17

löst ein Parameter pack mittels Operatoren auf. Siehe Fold (higher-order function).

(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.

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.

(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.

(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.

(engl. function, subroutine)

Programmteil, der eine Folge von Anweisungen 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 Parametern abhängig sein, die der Funktion beim Aufruf als Argumente mitgegeben werden. Eine Funktion kann als Ergebnis einen Rückgabewert liefern oder auch Seiteneffekte 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.

(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).

(engl. function prototype)

verbindet Rückgabetyp, Bezeichner und Liste der Parameter zur Deklaration einer Funktion.

(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.

(engl. function body)

Block, der auf einen Funktionskopf folgt, ist die Definition der Anweisungen, die beim Funktionsaufruf abzuarbeiten sind.

(engl. template function)

als Schablone definierte Funktion mit mindestens einem allgemein gehaltenen Parametertyp.

(Funktionsobjekt)

Schleife, deren Wiederholungs-Bedingung nach dem Schleifenrumpf steht. Der Anweisungs-Block wird mindestens einmal durchlaufen (nicht abweisender Test).

Veraltete Teile des Sprachstandards können in künftigen Standards entfernt werden. Es gibt bessere Lösungen.

(engl. information hiding)

von 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.

(engl. scope)

Quelltextabschnitt, in dem ein Bezeichner bekannt ist (lokal, global, Klasse, Namensraum).

(allgemeingültig, typunabhängig)

Definition und Anwendung von Schablonen.

nicht von Block-Klammern umgeben, im gesamten Programm existent, zugreifbar.

(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.

(engl. "has a" relationship, Komposition, Aggregation)

in umgekehrter Richtung: "ist Teil von".

Gesamtheit aller elektronischen und mechanischen Bestandteile eines Computersystems.

(Vorspanndatei, prototype file)

Quelltextdatei, die Funktionen, seltener globale Variablen, deklariert.

Typen und Konstanten können definiert werden. Die fehlerhafte mehrfache Definition muss unterbunden werden.

Headerdateien enthalten alle notwendigen Informationen über die Schnittstellen von Modulen und benutzerdefinierten Typen.

(dt. Halde)

Als 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:

       9
   8       6
 5   7   2   4   ==>   9 8 6 5 7 2 4 1 3 0
1 3 0  
     

Manchmal wird der Freispeicherbereich eines Programms für die dynamischer Speicherverwaltung ebenfalls als Heap bezeichnet.

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.

(engl. immediately invoked lambda expression)

Lambda-Ausdruck, der durch Funktionsaufruf sofort ausgewertet wird.

(lat. index = Zeiger, Zeigefinger)

ganzzahliger Wert, mit dessen Hilfe die Elemente eines Feldes 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".

(engl. instance, Objekt, Variable vom Klassentyp)

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".

(engl. "is a" relationship)

Zugehörigkeits-Beziehung zwischen einem Objekt und seiner Klasse.

(engl. "is a kind of" relationship)

asymmetrische Teilmengen-Beziehung einer abgeleiteten Klasse und ihrer Basisklasse.

(von lat. iterare = wiederholen)

zeigerartiges Objekt, mit dessen Hilfe Folgen von Objekten in einem Feld oder einem Container durchlaufen und angesprochen werden.

(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 (Zugriffsschutz) oft mit dem Verbergen von Information über den inneren Aufbau durch opake (undurchsichtige) Typen verbunden wird, werden Kapselung und Geheimnisprinzip gern verwechselt.

Anzahl der Elemente in einer Beziehung.

(engl. class)

zusammengesetzter Typ aus Attributen und Methoden zu deren Bearbeitung. Durch Einschränkung der Zugriffsrechte kann eine Kapselung erreicht werden. Variablen eines Klassen-Typs werden als Objekte 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.

(engl. class library)

organisierte Sammlung von Klassen.

Definition, legt Attribute einer Klasse fest, deklariert Köpfe von Methoden und verleiht Zugriffsrechte.

Deklaration, führt einen Klassennamen ein, muss die Klasse aber nicht definieren.

stellt die Konzepte Klasse, Attribute, Methoden und Beziehungen (Vererbung, Assoziation) in grafischer Form dar.

(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.

(engl. template class)

typparametrisierte Klasse, wird als Schablone definiert.

(engl. static member data)

Variable im Namensraum der Klasse, die nur einmal für die gesamte Klasse , unabhängig von der Existenz von Objekten vorhanden ist. Sie muss für das Binden außerhalb der Klasse in einem Modul definiert werden.

(Zusammenarbeit)

Kontext einer Menge von Interaktionen.

ein um Botschaften erweitertes Objektdiagramm, zeigt Interaktionen zwischen ausgewählten Objekten in einer bestimmten begrenzten Situation und betont die Beziehungen zwischen den Objekten und ihre Anordnung.

(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.

• 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.

(engl. member)

(Daten-)Bestandteil eines zusammengesetzten Typs.

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.

(Spezialisierung)

Ableitung einer konkreten Klasse aus einer abstrakten Klasse durch Vererbung und Überschreiben aller abstrakten Methoden, Bei Schablonen Definition eines konkreten Typs durch Festlegen der Typparameter einer Schablone.

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 Methoden haben nur Leserechte. Sie können nur lesend auf Attribute zugreifen und dürfen wiederum nur const-Methoden aufrufen. Andererseits sind allein konstante Methoden bei konstanten Objekten aufrufbar.

(engl. constructor, object factory, Fabrikmethode)

zur Klasse gehörende Erzeugerfunktion für ein Objekt, die das Objekt anlegt und dessen Attribute mit gültigen Werten belegt. Eine Klasse kann mehrere Konstruktoren mit unterschiedlichen Parameterlisten besitzen. Ein Konstruktor ohne Parameter wird Standardkonstruktor genannt.

(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. [ Informatik-Handbuch ] Diese Art von Kontravarianz ist in C++ nicht möglich, da beim Ü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 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.

(engl. copy constructor)

erzeugt ein Objekt als Kopie eines schon existierenden Objektes i.a. mit denselben Attributwerten.

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.

Software-Engineering: beschreibt die Stärke und Anzahl der Abhängigkeiten zwischen Einheiten eines Software-Systems (Modulen).

(lat. kovariant = sich mit verändernd)

Rückgabetypen 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.

(engl. lambda expression), ab C++11

aus funktionalen Programmiersprachen übernommenes Konzept einer anonymen oder Adhoc-Funktion. Diese Funktionsobjekte können lokal an der Stelle ihrer Benutzung definiert werden. Sie übernehmen dabei wahlweise Werte oder Referenzen ihrer Umgebung (Closure).

(engl. lifetime)

Existenzdauer einer Variable. C++ bietet drei Speicherkonzepte (Speicherklassen) an:

• Für automatische (lokale) 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 globale 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 Modulen 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.

Entwicklungswerkzeug, welches (getrennt) übersetzte Programmteile (Module) und Bibliotheken zum lauffähigen Programm zusammenfügt. In UNIX heißt dieses Programm "loader" (ld).

(hier: zweiwertige Aussagenlogik)

grundlegendes Teilgebiet der Mathematik. Der Logikkalkül wurde von George Boole (1815-1864) ausgearbeitet.

Aussageformen (Prädikate) lassen sich als bool-Funktionen 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 Schleifen und Entscheidungen.

innerhalb eines Blockes definiert, gültig, zugreifbar.

(engl. left hand value)

Ausdruck, der auf der linken Seite einer Zuweisung zulässig ist (aus BCPL).

durch #define festgelegter Bezeichner, der vom Präprozessor ausgewertet und bei weiteren Vorkommen im Quelltext ersetzt wird.

ein Makro mit Klammern und Parametern.

(engl. multiple inheritance)

Vererbung von mehreren Basisklassen zu einer abgeleiteten Klasse. Gleichnamige Attribute oder Methoden in den Basisklassen ruft Namenskonflikte hervor, die nachträglich aufgelöst werden müssen.

Verzweigung mit mehr als zwei möglichen Ausgängen (Anweisungsfolgen).

(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 Attribute des Objektes und auf Klassenvariablen. Nichtkonstante Methoden können den Objektzustand ändern.

kann (und sollte in C++ zumeist) außerhalb der Klassendefinition erfolgen (Trennung von Schnittstelle und Implementierung, Geheimnisprinzip).

erfolgt bei der Klassendefinition.

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.

Aufteilung der Programmquellen in Module 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.

(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!

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!

Übereinkunft einer Gruppe von Programmierern über die Schreibweise von Bezeichnern.

(engl. namespace)

Block, der die Sichtbarkeit von Bezeichnern 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.

(engl. object, instance variable)

Variable eines Klassentyps. Ein Objekt belegt alle in der Klasse definierten Attribute mit individuellen Werten (Identität) und kann die in der Klasse deklarierten Methoden 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.

vom Compiler aus einem Quelltext erzeugtes Zwischenprodukt mit verschieblichem Maschinencode, das in Bibliotheken aufgenommen oder beim Binden zu einem ausführbaren Programm komplettiert wird.

grafische Darstellung der Objekt-Beziehungen zu einem bestimmten Zeitpunkt, siehe auch Kollaborationsdiagramm.

enhält drei Konzepte: Objekt, Klasse, Vererbung.

verwendet die Konzepte Objekt, Klasse, Attribut, Methode, Assoziation, Vererbung, Botschaft zur Modellierung der Anforderungen an ein Softwareprodukt.

(objektorientiertes Design)

Im Vordergrund steht die Festlegung der Klassen, 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 Objekten gelöst. Dabei treten wiederkehrende Teilaufgaben auf, für die bereits Lösungen bekannt sind (Entwurfsmuster).

Philosophie des Programmierens, die von einer Welt ausgeht, die aus gleichberechtigten und einheitlich erscheinenden Objekten besteht. Objekte erledigen Aufgaben prinzipiell in eigener Verantwortung. Um die Fähigkeiten anderer Objekte nutzen zu können, schicken sich die Objekte Botschaften.

Die Definition einer Funktion oder einer globalen Variable darf nur genau einmal im gesamten Programm erfolgen. Übertretugnen dieser Regel führen zu Fehlern beim Binden (mehrfach definierte oder fehlende Symbole).

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.

im Funktionskopf hinter dem Funktionen aufgelistete lokale Variablen, die als Platzhalter für die beim Funktionsaufruf zu übernehmenden Argumente 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.

durch ... kenntlich gemachte unbestimmte Anzahl von Schablonenparametern, ab C++11.

(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.

Daten überleben das Programm. Daten existeren zwischen Programmausführungen, sogar verschiedenen Versionen eines Programms weiter.

(engl. plain old data structure)

Struktur oder Klasse ohne nutzerdefinierte Konstruktoren, Destruktor und ohne virtuelle Methoden.

(grch. Vielgestaltigkeit)

Gleichlautende Botschaften an Objekte verwandter, abgeleiteter Klassen bewirken unterschiedliches Verhalten.

Objekte abgeleiteter Klassen können dort eingesetzt werden, wo Zeiger oder Referenzen auf Objekte der Basisklasse erwartet werden. Für bestimmte, in der Basisklasse als virtuell markierte Methoden 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 Funktionen mit unterschiedlichen Parameterlisten überladen werden. Beim Funktionsaufruf wird anhand der übergebenen Argumenttypen entschieden, welche Funktion aufgerufen werden soll. Schablonen verallgemeinern dieses Überladen auf beliebige Argumenttypen.

Funktion mit booleschem Rückgabetyp

Entwicklungswerkzeug zum Einbinden von Dateien und zum Textersatz (Makros) während des Übersetzungsvorgangs.

(Rangfolge)

Herangehensweise und Auswahl der Sprachmittel für die Programmentwicklung:

• strukturiertes Programmieren : Einsatz von Verzweigungen und Schleifen zur Ablaufsteuerung
• funktionales Programmieren : Funktionen übernehmen unveränderliche Variablen als Platzhalter für Werte, die mit Operatoren 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 Prozeduren mit Parametern
• modulares Programmieren : Aufteilung des Quelltextes in inhaltlich zusammengehörende Abschnitte (Module)
• objektbasiertes Programmieren : Verwendung und evtl. auch Definition von Klassen
• objektorientiertes Programmieren : Einsatz von Vererbung und Polymorphie
• generisches Programmieren : Entwurf von typunabhängigen, typparametrisierten Funktionen und Klassen (Schablonen)

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.

(engl. void function, subroutine, procedure, Unterprogramm)

Programmteil, der eine Folge von Anweisungen 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.

(engl. source code)

in einer Programmiersprache geschriebenes Programmtext, das einem Compiler oder Interpreter übergeben wird.

(engl. resource acquisition is initialisation), auch AC/DC-Prinzip.

Besitzübernahme an angeforderten Ressourcen (Speicher, Dateien) durch Konstruktoren stellt sicher, dass Ressourcen durch den Destruktor automatisch freigegeben werden.

(Priorität)

legt fest, in welcher Reihenfolge unterschiedliche Operatoren 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 Funktionsaufrufe als Operanden ausgewertet werden. Haben die Funktionen sich Seiteneffekte, die sich gegenseitig beeinflussen, ist die Wirkung implementationsabhängig.

(engl. reference, Alias, Verweis)

Typ, der einen Bezeichner mit einem schon existierenden Objekt dauerhaft verbindet.

Typ für den von einer Funktion zurückgelieferten Wert.

Verschiebekonstruktor und Verschiebezuweisung erweitern seit C++11 die Regel der großen Drei. Sie erlauben dem Nutzer, verwaltete Ressourcen leicht in andere Objekte zu übertragen. Compiler folgen Regeln für das automatische Erzeugen bzw. Weglassen dieser speziellen Methoden. Die Kapselung der Ressourcenverwaltung in solchen Klassen erlaubt diese Nutzern, der Rule of Zero zu folgen.

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).

Gute Programmierpraxis kapselt die Ressourcenverwaltung in Attribut-Variablen. So definierte Klassen müssen gar keine speziellen Methoden deklarieren. Sie werden automatisch definiert, sofern die Bestandteile der Klasse Kopier- bzw. Verschiebeverhalten erlauben.

(engl. right-hand side value)

Ausdruck, der auf der rechten Seite einer Zuweisung stehen darf.

T&& … Verweis auf einen rvalue, der Verschiebesemantik erlaubt. Für Funktionsparameter dieser Art wurde die Bezeichnung "weiterleitende Referenz" (forwarding reference) eingeführt.

(engl. return value optimization)

vermeidet unnötige Kopie des Rückgabewertes einer Funktion.

(engl. template, Vorlage)

allgemeingültige (generische) Funktion oder Klasse, bei deren Definition ein oder mehrere Typen und / oder ganzzahlige Konstanten bewusst nicht festgelegt werden. Die Festlegung dieser Schablonen-Parameter erfolgt bei Bedarf durch Spezialisierung beim Übersetzen eines Funktionsaufrufs bzw. Bildung einer konkreten Klasse.

(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 kopfgesteuert bzw. fußgesteuert bezeichnet. Ist die Testbedingung stets erfüllt, liegt eine Endlosschleife vor.

(engl. keyword)

reservierter Bezeichner mit besonderer, in der Programmiersprache festgelegter Bedeutung.

(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 (Modulen), erleichtert Benutzung und Fehlersuche.

Die Schnittstelle einer Funktion ist ihr Funktionskopf. Die Schnittstelle einer Klasse umfasst alle öffentlich zugänglichen Bestandteile (Attribute und Methoden).

Einige Operatoren 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 Funktionen und Methoden 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:

int a = 1;
int b = a++ + a--; // Welchen Wert hat b? 1, 2 oder 3 ?

(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.

(SIMULAtion language)

von Ole-Johan Dahl und Kristian Nygaard 1965-1967 entworfene Programmiersprache für ereignisgesteuerte Simulationen, Ableger von ALGOL, mit Objektkonzept und Koroutinen.

grafische, zeitbasierte Darstellung von Botschaften mit vertikaler Zeitachse, siehe auch: Kollaborationsdiagramm.

objektorientierte Programmiersprache und Programmierumgebung, 1974/1980 im XEROX PARC entwickelt.

Gesamtheit aller zur Steuerung einer Datenverarbeitungsanlage (Computer) notwendingen Programme und Daten.

(dt. Softwaretechnik)

Ingenieurdisziplin, die sich mit planvollem Entwurf, Entwicklung und Organisation von Software-Systemen befasst.

(engl. garbage collection)

Mechanismus in der Laufzeitumgebung (objektorientierter) Softwaresysteme, mit dem der Speicherbereich nicht mehr benutzter Objekte 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 Bibliotheken eingebunden werden.

(engl. storage class)

legt Lebensdauer lokaler Variablen (automatisch, statisch oder Register) bzw. die Bindung (Sichtbarkeit) globaler Bezeichner (statisch oder extern) fest.

taxonomische Beziehung zwischen einer allgemeinen und der speziellen Einheit, wobei das speziellere weitere Eigenschaften (Attribute) hinzufügt, die Semantik erweitert und sich kompatibel zum allgemeinen verhält.

(engl. jump)

Anweisung, das Programm an anderer Stelle fortzusetzen. In C ist der Sprung auf das Innere einer Funktionsrumpfes beschränkt.

Konstruktor, erstellt ein Objekt ohne Angabe von Parametern.

Verzweigungen und Schleifen gestatten Abweichungen von der sequentiellen Abarbeitung von Anweisungen.

(engl. standard template library)

ursprünglich von Alexander Stepanov und Meng Lee vorgeschlagene Schablonenbibliothek für Algorithmen und Container, die in C++98 eingeflossen ist.

Auch:Stephan T. Lavavej, Microsofts Betreuer der C++-Bibliothek des Visual Studio C++ Compilers.

seit C++17: Definition mehrerer Variablen aus den Bestandteilen von Struktur, Feld o.ä.

(engl. structure, record, Datenverbund)

benutzerdefinierter Typ, der mehrere Komponenten als Einheit zusammenfasst.

(Grammatik)

bestimmte Folge von Aktionen, z.B. ein konkreter Ablaufpfad in einem Anwendungsfall, siehe Sequenzdiagramm.

(engl. template meta programming)

nutzt die Auswertung von Schablonen durch den Compiler zur Berechnung.

Festlegung von Speicherplatzbedarf, Wertebereich und Operationen, wird bei der Übersetzung überprüft und Variablen zugeordnet.

Neben einfachen Grunddatentypen und in Bibliotheken vordefinierten Typen können vom Programmierer eigene Typen festgelegt und benutzt werden. Strukturen und Klassen sind zusammengesetzte Typen.

zwangsweise Uminterpretation des Speicherabbildes einer Variable, setzt die Typ-Prüfung des Compilers außer Kraft. Die Verantwortung für die Sinnhaftigkeit muss der Programmierer übernehmen.

(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 Konstruktoren und durch Typumwandlungs-Operatoren festlegen.

(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 Parametern unterschiedlicher Typen erlaubt statische Polymorphie.

(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.

(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.

Eine Quelltextdatei, die getrennt von anderen übersetzt wird (siehe auch Modul).

(engl. Unified Method Language)

graphische Notation für objektorientierte Softwareentwürfe, u.a.

• Klassendiagramm,
• Objektdiagramm,
• Kollaborationsdiagramm,
• Sequenzdiagramm,
• Zustandsdiagramm.

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.

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 

(abgeleitete Klasse)

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.

(Generalisierung, Abstraktion)

geistiges Verfahren zur Zusammenfassung gemeinsamer Eigenschaften einer Gruppe von Klassen als Basisklasse.

(engl. responsibility, Zuständigkeit)

umfasst die Attribute und die interpretierbaren Botschaften eines Objekts.

benutzerdefinierter zusammengesetzter Typ, dessen Komponenten denselben Speicherplatz überdecken.

(engl. inheritance, Typerweiterung, Ableitung)

programmiersprachliches Konzept für die Umsetzung einer Beziehung zwischen einer Basisklasse und einer 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.

(Klassenhierarchie)

Geflecht der Vererbungsbeziehungen in einem objektorietierten System, bei Einfachvererbung ein Baum oder Wald, bei Mehrfachvererbung ein gerichteter, azyklischer Graph.

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.

(engl. move constructor)

erzeugt ein Objekt mit den Attributwerten einer rvalue-Referenz. Das neue Objekt übernimmt den Besitz an den Ressourcen und hinterlässt diese als leere Hülle (Verschiebesemantik).

Besitzübernahme durch Verschiebekonstruktoren und Verschiebezuweisung. Die übernommene Rvalue-Referenz ist danach nicht mehr im Besitz der von ihr verwalteten Ressourcen.

(Auswahl, Entscheidung)

Steueranweisung, die anhand einer Bedingung entscheidet, welche von zwei oder mehreren Anweisungen bzw. Anweisungsfolgen ausgeführt werden muss.

(engl. virtual base class)

Bei der Vererbung über mehrere Vererbungspfade (Rhombusmuster bei Mehrfachvererbung) wird nur ein gemeinsames Basisklassenobjekt angelegt.

(engl. virtual member function, polymorphe Methode)

realisiert dynamische Polymorphie. Erst zur Laufzeit wird bestimmt, welche Operation ausgeführt wird (dynamische, späte Bindung).

Zustand, der vor dem Ablauf einer Operation gegeben sein muss (Zusicherung).

Menge der möglichen Datenwerte eines Typs.

(engl. reusability)

Entwurfziel zur Erhöhung der Produktivität beim Softwareentwurf.

(engl. pointer)

Typ, dessen Objektwerte Speicheradressen von (anderen) Objekten sind. Über Zeiger sind zeitweilige Verweise und Zugriffe auf Daten (Variablen, Objekte) im Hauptspeicher möglich. Zeiger sind an einen Typ gebunden, der zu den verwiesenen Daten passen muss.

Rechenregeln für den Umgang mit Zeigern in zusammenhängenden Speicherbereichen (Feldern).

(engl. granted access)

von Klassen und Strukturen zu verleihende Erlaubnis, Komponenten und Methoden 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.

(engl. assertion, Behauptung)

Bedingungen für einen korrekten Ablauf einer Anweisung oder Anweisungsfolge. Vorbedingungen 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.

(engl. state)

wird bestimmt durch die Attributwerte des Objektes und seine Verbindungen zu anderen Objekten, die zu einem bestimmten Zeitpunkt existieren.

(engl. state transition diagram)

grafische Darstellungsform eines Zustandsautomaten.

(engl. assignment)

Ausdruck, der einer Variable (allgemeiner einem lvalue) einen neuen Wert zuweist.

1. Balzert, Helmut: Lehrbuch der Software-Technik. Spektrum, Heidelberg (2000).
2. Booch, Grady: Object Oriented Design with Applications. Benjamin Cummings, Redwood (1991).
3. Herkunftswörterbuch. Bertelsmann, Gütersloh (1998).
4. Informatik-Duden. Dudenverlag, Mannheim (1993).
5. McGregor, John D.; Sykes, David A.: Object-Oriented Software Development: Engineering Software for Reuse. Van Nostrand Reinhold, New York (1992).
6. Oesterreich, Bernd: Objektorientierte Software-Entwicklung. Oldenbourg, München (1998).
7. Rechenberg, Peter; Pomberger, Gustav: Informatik-Handbuch. Hanser, München (1999).
8. Stroustrup, Bjarne: Die C++ Programmiersprache. 3. Aufl. Addison-Wesley, Bonn (1998).
9. http://en.cppreference.com/w/