namespace cpp {}

C++ lernen, kennen, anwenden

Benutzer-Werkzeuge

Webseiten-Werkzeuge


kennen:keywords

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.


kennen:keywords [2020-07-18 12:24] (aktuell) – angelegt - Externe Bearbeitung 127.0.0.1
Zeile 1: Zeile 1:
 +====== Schlüsselwörter ======
 +> Dinge, die erst erklärt werden müssen, sind oft der Erklärung nicht wert.
 +>>---  Voltaire
 +
 +Schlüsselwörter sind reservierte Bezeichner mit vordefinierter Bedeutung.
 +Sie können nicht als Namen für Variablen, Funktionen, Klassen usw. benutzt werden.
 +Darüber hinaus sind die Operatornamen 
 +
 +<code cpp>
 +not         compl    ~      not_eq   !=
 +and   &&      bitand   &      and_eq   &=
 +or    ||      bitor    |      or_eq    |=
 +              xor      ^      xor_eq   ^=
 +</code>
 +für einige [[operator#Rangfolge|Operatoren]]
 +wie Schlüsselwörter zu behandeln.
 +Nur an bestimmten Stellen haben die Bezeichner 
 +[[.:beispiel:override|final]], 
 +[[.:beispiel:export|import]], 
 +[[.:beispiel:export|module]] und
 +[[.:beispiel:override|override]] 
 +besondere Bedeutung.
 +
 +
 +
 +
 +===== alphabetisch =====
 +<WRAP col5>
 + [[#alignas]]\\
 + [[#alignof]]\\
 + [[#asm]]\\
 + [[#auto]]\\
 + [[#bool]]\\
 + [[#break]]\\
 + [[#case]]\\
 + [[#catch]]\\
 + [[#char]]\\
 + [[#char8_t]]\\
 + [[#char16_t]]\\
 + [[#char32_t]]\\
 + [[#class]]\\
 + [[#co_await]]\\
 + [[#co_return]]\\
 + [[#co_yield]]\\
 + [[#concept]]\\
 + [[#const]]\\
 + [[#const_cast]]\\
 + [[#consteval]]\\
 + [[#constexpr]]\\
 + [[#constinit]]\\
 + [[#continue]]\\
 + [[#decltype]]\\
 + [[#default]]\\
 + [[#delete]]\\
 + [[#do]]\\
 + [[#double]]\\
 + [[#dynamic_cast]]\\
 + [[#else]]\\
 + [[#enum]]\\
 + [[#explicit]]\\
 + [[#export]]\\
 + [[#extern]]\\
 + [[#false]]\\
 + [[#float]]\\
 + [[#for]]\\
 + [[#friend]]\\
 + [[#goto]]\\
 + [[#if]]\\
 + [[#inline]]\\
 + [[#int]]\\
 + [[#long]]\\
 + [[#mutable]]\\
 + [[#namespace]]\\
 + [[#new]]\\
 + [[#noexcept]]\\
 + [[#nullptr]]\\
 + [[#operator]]\\
 + [[#private]]\\
 + [[#protected]]\\
 + [[#public]]\\
 + <del>[[#register]]</del>\\
 + [[#reinterpret_cast]]\\
 + [[#requires]]\\
 + [[#return]]\\
 + [[#short]]\\
 + [[#signed]]\\
 + [[#sizeof]]\\
 + [[#static]]\\
 + [[#static_assert]]\\
 + [[#static_cast]]\\
 + [[#struct]]\\
 + [[#switch]]\\
 + [[#template]]\\
 + [[#this]]\\
 + [[#thread_local]]\\
 + [[#throw]]\\
 + [[#true]]\\
 + [[#try]]\\
 + [[#typedef]]\\
 + [[#typeid]]\\
 + [[#typename]]\\
 + [[#union]]\\
 + [[#unsigned]]\\
 + [[#using]]\\
 + [[#virtual]]\\
 + [[#void]]\\
 + [[#volatile]]\\
 + [[#wchar_t]]\\
 + [[#while]]
 +</WRAP>
 +===== nach Aufgaben =====
 +Schlüsselwörter der Sprache C sind durch einen nachfolgenden Stern * gekennzeichnet, in modernem C++ hinzugekommene als 
 +¹[[begriffe#C++11]], 
 +°[[begriffe#C++20]] gekennzeichnet, <del>durchgestrichene</del> sind geächtet oder entfallen.
 +
 +| Grunddatentypen | Wahrheitswerte     | [[#bool]], [[#true]], [[#false]]|
 +|                 | Zeichen und Zahlen | [[#char]]*, [[#char8_t]]°, [[#char16_t]]¹, [[#char32_t]]¹, [[#wchar_t]]|
 +|                 | Zahlen             | [[#double]]*, [[#float]]*, [[#int]]*,|
 +|                 | weitere            | [[#auto]]¹, [[#enum]]*, [[#typedef]]*, [[#void]]*|
 +| Modifizierer für| Platzbedarf        | [[#long]]*, [[#short]]*|
 +|                 | Vorzeichen         | [[#signed]]*, [[#unsigned]]*|
 +|                 | Veränderbarkeit    | [[#const]]*, [[#consteval]]°, [[#constexpr]]¹, [[#constinit]]°, [[#mutable]], [[#volatile]]*|
 +|                 | Lebensdauer / Ort  | [[#alignas]]¹, [[#extern]]*, [[#static]]*, [[#thread_local]]¹|
 +| Zusammengesetzte Typen | Klassen & Strukturen | [[#class]], [[#struct]]*, [[#union]]*, [[#explicit]], [[#this]], [[#virtual]]|
 +|                 | Zugriffsrechte     | [[#friend]], [[#private]], [[#protected]], [[#public]]|
 +| Concepts        |                    | [[#concept]]°, [[#requires]]°|
 +| Typinformation  |                    | [[#alignof]]¹, [[#decltype]]¹, [[#sizeof]]*, [[#typeid]], [[#typename]]|
 +| Typumwandlung   | (type casts)       | [[#const_cast]], [[#dynamic_cast]], [[#reinterpret_cast]], [[#static_cast]]|
 +| Ablaufsteuerung | Schleifen          | [[#do]]*, [[#for]]*, [[#while]]*|
 +|                 | Verzweigungen      | [[#else]]*, [[#default]]*, [[#if]]*, [[#switch]]*, [[#case]]*|
 +|                 | Sprünge            | [[#break]]*, [[#continue]]*, [[#goto]]*|
 +|                 | Ausnahmebehandlung | [[#catch]], [[#noexcept]]¹, [[#static_assert]]¹, [[#throw]], [[#try]]|
 +|                 | Couroutinen        | [[#co_wait]]°, [[#co_return]]°, [[#co_yield]]°|
 +| Assemblercode                      | [[#asm]]|
 +| Freispeicher    |                    | [[#delete]], [[#new]], [[#nullptr]]¹|
 +| Funktionen      |                    | [[#inline]], [[#operator]], [[#return]]*|
 +| Namensbereiche  |                    | [[#namespace]], [[#using]]|
 +| Modularisierung |                    | [[#export]]°|
 +| Schablonen      |                    | [[#template]]|
 +| reserviert      |                    | <del>[[#register]]</del>|
 +
 +Aufgeführte Jahreszahlen geben den Zeitpunkt der Einführung bzw. Bedeutungsänderung im Sprachstandard (C++ ISO 14882) an.
 +===== Erläuterungen =====
 +==== alignas ====
 +C++11 : Die Ausrichtung von Elementen an Adressgrenzen von 1, 2, 4, 8, ... Byte ist von Bedeutung, wenn Daten über Plattformgrenzen transportiert werden, z.B. von CPU zu GPUs.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|      | [[#alignof]], [[#sizeof]]| - |
 +
 +==== alignof ====
 +C++11 : liefert Abstand aufeinander folgender (Feld-)Elemente dieses Typs in Byte.   
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|      | [[#alignas]], [[#sizeof]]| - |
 +
 +==== asm ====
 +C++ : Das Schlüsselwort ''asm'' dient zum Einbinden von Assembler-Anweisungen
 +in Funktionen. Die Bedeutung ist plattform- und implementierungsabhängig. 
 +(Mit anderen Worten: Wer es benutzt, sollte vorher genau wissen, was er tut.)
 +
 +==== auto ====
 +C : Das Schlüsselwort ''auto'' ist ein Relikt 
 +aus der Programmiersprache [[begriffe#BCPL]] 
 +zur Kennzeichnung von automatisch angelegten und beseitigten Variablen
 +im Gegensatz zu statischen ([[#static]]) Variablen. 
 +Der (veraltete) Variablen-Modifizierer wird kaum noch benutzt.
 +Falls nicht anders gekennzeichnet, sind alle (lokalen) Variablen automatisch.
 +
 +C++03 : geächtet
 +
 +C++11 : Der Typ wird bei der Definition einer Variable automatisch aus dem zugewiesenen Wert erschlossen (type inference). 
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|      | - | Beispiel [[.beispiel:auto]], [[.beispiel:range_based_for]]|
 +
 +
 +
 +==== bool ====
 +C++98 : Der ''bool''-Datentyp nimmt die Wahrheitswerte [[#true]]
 +und [[#false]]
 +auf. Bei der Zuweisung aus anderen Typen wird Null zu ''false'',
 +jeder andere Wert zu ''true''. [[begriffe#Schleife|Schleifen]] 
 +und [[begriffe#Verzweigung|Verzweigungen]]
 +werden mit logischen Ausdrücken gesteuert.
 +Die zweiwertige [[begriffe#Logik]]
 +ist nach George Boole benannt.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|      | [[#false]], [[#true]]| [[.:beispiel:bool]]|
 +
 +==== break ====
 +C, C++ : Das Schlüsselwort ''break'' weist das Verlassen einer 
 +[[begriffe#Mehrfachverzweigung|Mehrfachverzweigung]]
 +([[#switch]]) oder den Abbruch einer (der innersten) 
 +[[begriffe#Schleife|Schleife]] an.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#case]], [[#default]],  [[#switch]]| [[.:beispiel:switch]]|
 +| | [[#continue]],  [[#do]],  [[#for]], [[#while]]| [[.:beispiel:forbreak]]|
 +
 +==== case ====
 +C, C++ : Das Schlüsselwort ''case'' (dt. Fall / falls, Testwert) 
 +markiert einen Einsprungpunkt im Anweisungsblock einer 
 +[[begriffe#Mehrfachverzweigung]].
 +Nur ganzzahlige Konstanten sind erlaubt, jeder Wert muss einzeln aufgeführt werden.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#break]], [[#default]],  [[#switch]]| [[.:beispiel:switch]]|
 +
 +==== catch ====
 +C++98 : 
 +Mit dem Schlüsselwort ''catch'' beginnt ein Abschnitt zur 
 +[[begriffe#Ausnahmebehandlung]].
 +Es darf nur im Anschluss an einen [[#try]]-Block mit "unsicheren" Anweisungen erscheinen,
 +die direkt oder indirekt eine [[begriffe#Ausnahme]]
 +werfen ([[#throw]]) können.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#throw]], [[#try]]| [[.:beispiel:except]]|
 +
 +==== char ====
 +C, C++ : Der Grunddatentyp ''char'' (character) erfasst Zeichen. 
 +--- Vorsicht! Das Byte wird als [[#sizeof]]''(char)==1'' aufgefasst, d.h. nicht unbedingt 8 bit!
 +
 +Ob die Zeichen intern den Zahlenwerten 0..255 (vorzeichenlos) 
 +oder -128..127 (vorzeichenbehaftet) zugeordnet werden,
 +hängt von den Compiler-Einstellungen ab.
 +Welche Nummer welches Zeichen darstellt, ist maschinen- und systemabhängig.
 +So hat der Großbuchstabe 'A' die Nummer 65 im ASCII-Zeichensatz,
 +auf Maschinen mit EBCDIC-Zeichensatz (entpackt) jedoch die Nummer 193.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#char16_t]], [[#char32_t]], [[#wchar_t]]| [[.:beispiel:typen]]|
 +
 +==== char16_t ====
 +C++11 : Zeichentyp mit 16 bit Breite.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#char]], [[#char32_t]], [[#wchar_t]]| [[.:beispiel:typen]]|
 +
 +==== char32_t ====
 +C++11 : Zeichentyp mit 32 bit Breite.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#char]], [[#char16_t]], [[#wchar_t]]| [[.:beispiel:typen]]|
 +
 +==== class ====
 +C++ : Das Schlüsselwort ''class'' leitet die Deklaration bzw. Definition einer [[begriffe#Klasse]]
 +ein. Klassen und Strukturen ([[#struct]]) sind in C++ gleichwertig
 +mit einer Ausnahme: Das voreingestellte [[begriffe#Zugriffsrecht]]
 +einer Klasse ist [[#private]].
 +Mit Klassen wird das Typsystem für objektorientiertes Programmieren aufgebaut.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#struct]]| [[.:beispiel:class]]|
 +
 +
 +==== co_await ====
 +C++20:
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| [[kennen:coroutine]] | [[#co_return]] [[#co_yield]] | |
 +
 +==== co_return ====
 +C++20:
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| [[kennen:coroutine]] | [[#co_await]] [[#co_yield]] | |
 +
 +==== co_yield ====
 +C++20:
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| [[kennen:coroutine]] | [[#co_await]] [[#co_return]] | |
 +
 +==== concept ====
 +C++20: ein zur Übersetzungszeit auswertbares [[.:begriffe#Prädikat]], definiert eine benannte Anforderung an [[.:begriffe#Schablone]]n.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| [[kennen:concepts]] | [[#requires]] | [[.:beispiel:concept]]|
 +
 +==== const ====
 +C, C++ : Mit dem Schlüsselwort ''const'' markierte Variablen, Zeiger oder Objekte 
 +werden als unveränderlich betrachtet. Zumindest behindert ''const'' die 
 +Wertänderung über den nachfolgenden Bezeichner.\\
 +
 +In C++ können auch [[begriffe#Methode|Methoden]] 
 +mit ''const'' als nur lesende Methoden markiert werden 
 +([[begriffe#UML]]-Eigenschaftswert ''{readonly}''). 
 +Solche Methoden ändern die Attributwerte 
 +des aufrufenden Objektes nicht.\\
 +
 +Bei ''const''-Objekten können nur ''const''-Methoden benutzt werden.\\
 +
 +Der richtige und konsequente Einsatz (const correctness)
 +trägt zur Verbesserung der Softwarequalität bei.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#constexpr]], [[#mutable]]| [[.:beispiel:const]]|
 +
 +==== const_cast ====
 +C++98 : Ein ''const_cast'' 
 +ist eine auffällige Form eines [[begriffe#Typecast]],
 +bei dem das Schreibschutzsystem für Variablen ([[#const]]) 
 +bewusst ausgehebelt wird.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#static_cast]], [[#reinterpret_cast]]| [[.:beispiel:typecast]]|
 +
 +
 +
 +==== consteval ====
 +C++20: [[#Funktion]] kann nur zur Übersetzungszeit aufgerufen werden.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#constexpr]], [[#constinit]]| |
 +
 +==== constexpr ====
 +C++11 : markiert Ausdruck, dessen Auswertung zur Übersetzungszeit erfolgen kann, sofern seine Bestandteile ebenfalls vom Übersetzer bestimmt werden können. 
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#const]], [[#mutable]]| [[.:beispiel:constexpr]]|
 +
 +==== constinit ====
 +C++20: Variable wird zur Übersetzungszeit initialisiert.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#constexpr]], [[#consteval]]| |
 +
 +==== continue ====
 +C, C++ : Das Schlüsselwort ''continue'' weist an, 
 +die Anweisungen bis zum Ende eines Schleifenblockes zu überspringen. 
 +Die [[begriffe#Schleife]] 
 +wird dadurch nicht abgebrochen (s. [[#break]]). 
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#break]], [[#do]],  [[#for]], [[#while]]| [[.:beispiel:continue]]|
 +
 +==== decltype ====
 +C++11 : erschließt Typ eines Ausdrucks (type inference), 
 +nützlich vor allem bei der Definition von [[begriffe#Schablone|Schablonen]].
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[.beispiel:auto]], [[#template]]| [[.:beispiel:decltype]]|
 +
 +==== default ====
 +C, C++ : Der mit ''default:'' (dt. Vorgabe) markierte Zweig
 +in einer [[begriffe#Mehrfachverzweigung]]
 +([[#switch]]-Anweisung) wird ausgeführt, 
 +wenn keiner der einzeln aufgeführten Fälle ([[#case]]) zutrifft.
 +
 +C++11 : Ein ''= default'' markierter 
 +[[begriffe#Destruktor]], [[begriffe#Konstruktor]] oder [[begriffe#Zuweisung|Zuweisungsoperator]]
 +einer [[begriffe#Klasse]] oder [[begriffe#Struktur]]
 +wird vom Compiler mit dem Standardverhalten implementiert.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|    | [[#case]],  [[#switch]]| [[.:beispiel:switch]]|
 +|    | [[#class]], [[#delete]], [[#struct]] | [[.:beispiel:default]] |
 +==== delete ====
 +C++ : Der Operator ''delete'' zerstört dynamische Objekte und gibt deren Speicher frei,
 +der mit [[#new]]
 +angefordert wurde.
 +Nach der Freigabe darf auf den Speicher nicht mehr zugegriffen werden.
 +Die hinterlegte Adresse sollte gelöscht werden,
 +um unabsichtliche Zugriffe über "baumelnde [[begriffe#Zeiger]]" zu verhindern.
 +
 +C++11 : Eine ''= delete'' markierte Funktion, auch 
 +[[begriffe#Destruktor]], [[begriffe#Konstruktor]] oder [[begriffe#Zuweisung|Zuweisungsoperator]]
 +einer [[begriffe#Klasse]] oder [[begriffe#Struktur]]
 +wird vom Compiler nicht implementiert, ihr Aufruf ist nicht erlaubt.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#new]], [[#nullptr]]| [[.:beispiel:new]]|
 +|             | [[#class]], [[#default]], [[#struct]] | [[.:beispiel:default]] |
 +==== do ==== 
 +C, C++ : Das Schlüsselwort ''do'' leitet eine
 +[[begriffe#fußgesteuerte Schleife]]
 +ein.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#while]]| [[.:beispiel:while]]|
 +
 +==== double ====
 +C, C++ : Der Grunddatentyp ''double'' nimmt Fließkommazahlen mit 
 +erhöhter Zahl bedeutsamer Stellen ("doppelt genau")
 +und erweitertem Exponentenbereich auf.
 +Die Typbezeichnung ''long float'' ist gleichbedeutend.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#float]]| [[.:beispiel:typen]]|
 +
 +==== dynamic_cast ====
 +C++98 : Ein ''dynamic_cast'' 
 +ist eine auffällige Form eines [[begriffe#Typecast]]
 +für den "Downcast" in Vererbungshierarchien,
 +bei dem geprüft wird, ob ein Objekt die Schnittstelle einer 
 +[[begriffe#Unterklasse]]
 +anbieten kann.
 +Kann die Umwandlung nicht vorgenommen werden, wird bei Zeigern ein NULL-Zeiger geliefert,
 +bei Referenzen eine ''bad_cast''-Ausnahme geworfen.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#static_cast]], [[#reinterpret_cast]]| [[.:beispiel:typecast]]|
 +==== else ====
 +C, C++ : Das Schlüsselwort ''else'' leitet den "Sonst"-Zweig einer 
 +[[begriffe#Verzweigung]]
 +ein. Davor muss eine [[#if]]-Anweisung stehen. 
 +Bei mehreren vorangehenden ''if'' bindet ''else'' 
 +stets an das unmittelbar vorherige ''if'' im gleichen Block.  
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#if]]| [[.:beispiel:ifelse]]|
 +
 +==== enum ====
 +C, C++ : Mit ''enum'' werden Aufzählungstypen (engl. enumeration) definiert
 +und diesen Werte aus einer Liste von ganzzahligen Konstanten zugeordnet.
 +
 +C++11 : Als ''enum class'' oder ''enum struct'' markierte Aufzählkonstanten sind typsicher,
 +Sie werden nicht implizit in Ganzzahlen umgewandelt.
 +Der darunterliegende Ganzzahltyp kann explizit und im Voraus festgelegt werden: ''enum class E : unsigned long;''
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#const]]| [[.:beispiel:typen]]|
 +
 +
 +==== explicit ====
 +C++98 : 
 +Das Schlüsselwort ''explicit'' (dt. ausdrücklich) 
 +vor einem [[begriffe#Konstruktor]]
 +mit nur einem Parameter erzwingt, dass dieser Konstruktor zur Typumwandlung
 +im Quelltext ausgeschrieben werden muss.
 +Das verhindert die unabsichtliche automatische (implizite) 
 +Typumwandlung einzelner Werte bei Zuweisungen.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#class]]| [[.:beispiel:explicit]]|
 +
 +==== export ====
 +C++11 : für künftige Bedeutungen reserviert.
 +
 +C++20 : [[.:module]] geben damit bekannt, welche Namen zur öffentlichen [[.:module#Schnittstelle]] gehören. 
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|                  | [[.:beispiel:export]]|
 +
 +==== extern ====
 +C, C++ : Das Schlüsselwort ''extern'' zeigt an, 
 +dass die deklarierte Variable oder Funktion anderswo, 
 +möglicherweise in einer anderen Quelltextdatei definiert wird.
 +
 +Funktionen haben stets externe Bindung, sofern sie nicht als [[#static]]
 +markiert sind.
 +
 +Bei Funktionen kann die externe Bindung für andere Programmiersprachen
 +festgelegt werden.
 +Das ist u.a. dann nötig, wenn mit C++ übersetzte Funktionen
 +in ein C-Programm eingebunden werden sollen.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#static]]     | [[.:beispiel:extern]]|
 +
 +==== false ====
 +C++98 : Der Wahrheitswert ''false'' (dt. falsch) hat den Wert 0.
 +Er dient als Ergebniswert bei nicht erfülltem logischem Test.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|       | [[#bool]], [[#true]]| [[.:beispiel:bool]]|
 +
 +
 +==== float ====
 +C, C++ : Der Grunddatentyp ''float'' nimmt Fließkommazahlen
 +mit "einfacher" Genauigkeit auf. 
 +Typisch sind 6 oder 7 Dezimalstellen vertrauenswürdig.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#double]]| [[.:beispiel:typen]]|
 +
 +==== for ====
 +C, C++ : Das Schlüsselwort ''for'' leitet eine 
 +[[begriffe#kopfgesteuerte Schleife]] oder Zählschleife
 +ein. Im Steuerteil der for-Anweisung gibt es einen Ausdruck für Startwerte,
 +eine Durchführungs-[[begriffe#Bedingung]]
 +und den nach jedem Durchlauf auszuwertenden Ausdruck für den Schleifenschritt.
 +Jede ''for''-Anweisung kann in eine gleichwertige [[#while]]-Anweisung
 +umgeschrieben werden.
 +
 +C++11 : Die //range based for//-Anweisung erlaubt Formulierungen der Art //für jedes Element aus dem Bereich ...//.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#while]]| [[.:beispiel:for]]|
 +|                       | [[.beispiel:auto]], [[.beispiel:range_based_for]]|
 +
 +==== friend ====
 +C++ : Mit dem Schlüsselwort ''friend'' erklärt eine Klasse
 +eine andere Klasse oder eine Funktion zum Freund.
 +Dem Freund wird der Zugriff auf nicht-öffentliche Bestandteile der Klasse erlaubt.
 +Es spielt keine Rolle, ob die Freund-Deklaration in einem öffentlichen oder
 +nicht-öffentlichen Abschnitt der Klassendefinition steht.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#private]], [[#protected]], [[#public]]| [[.:beispiel:class]]|
 +
 +==== goto ====
 +C, C++ : Mit dem Schlüsselwort ''goto'' wird ein [[begriffe#Sprung]]
 +angewiesen.
 +Sprünge sind in C und C++ nur eingeschränkt möglich. 
 +Sie dürfen nur innerhalb einer Funktion stattfinden.
 +Ein Sprung darf keine Variablendefinition überspringen.
 +Bis auf wenige, komplizierte Situationen kann ''goto'' durch
 +durch strukturiertere Sprachmittel ([[begriffe#Schleife]]
 +oder [[begriffe#Verzweigung]]) ersetzt werden.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#do]], [[#else]], [[#if]], [[#for]], [[#while]]| [[.:beispiel:goto]]|
 +
 +==== if ====
 +C, C++ : Das Schlüsselwort ''if'' markiert den Beginn einer 
 +[[begriffe#Entscheidung]].
 +Nach der zu erfüllenden [[begriffe#Bedingung]]
 +und dem "Dann"-Zweig kann ein [[#else]]-Block folgen,
 +muss aber nicht.
 +Mit if-else-if-Leitern und [[#switch]]-Anweisungen können 
 +[[begriffe#Mehrfachverzweigung|Mehrfachverzweigungen]]
 +realisiert werden.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|     | [[#else]], [[#switch]]| [[.:beispiel:ifelse]]|
 +
 +==== inline ====
 +C++ : Als ''inline'' markierte 
 +[[begriffe#Funktion|Funktionen]]
 +vermeiden beim Aufruf den Aufwand eines Funktionsaufrufes 
 +(Parameterübergabe, Aufbau eines Stapelrahmens, Sprungbefehl, 
 +Stapelausrichtung, Ablage des Ergebnisses, Abbau des Stapels, Rücksprung). 
 +Für Funktionen mit sehr wenigen Anweisungen kann sich daraus ein
 +Geschwindigkeitsgewinn ergeben.
 +Gleichzeitig wird die Typprüfung vollständig durchgeführt.
 +Deshalb sind ''inline''-Funktionen sicherer als 
 +[[begriffe#Präprozessor]]-Makros.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | - | [[.:beispiel:inline]]|
 +
 +==== int ====
 +C, C++ : Der Grunddatentyp ''int'' nimmt vorzeichenbehaftete Ganzzahlen auf.
 +Die Speicherbreite eines ''int'' entspricht i.a. der Verarbeitungsbreite des 
 +Prozessors. 
 +Je nach Zielsystem können das 16 bit, 32 bit oder auch (demnächst) 64 bit sein.
 +Durch vorangestellte Modifizierer kann der Datentyp variiert werden:
 +
 +
 +  * [[#unsigned]]-Typen werden als vorzeichenlos interpretiert,
 +  * [[#short]]-Typen sind typisch 16 bit breit,
 +  * [[#long]]-Typen haben zumeist 32 bit.
 +Damit ist auch der [[begriffe#Wertebereich]]
 +systemabhängig.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#long]], [[#short]], [[#signed]], [[#unsigned]]| [[.:beispiel:typen]]|
 +
 +==== long ====
 +C, C++ : Der Modifizierer ''long'' ist bei den Datentypen [[#int]], [[#float]]
 +und [[#double]]
 +zulässig. Je nach System wird dadurch ein Typ mit größerem Speicherplatzbedarf
 +und erweitertem [[begriffe#Wertebereich]]
 +angegeben. 
 +Nicht jede Kombination ergibt jedoch einen neuen Typ, 
 +z. B. ist ''long float'' gleichbedeutend mit ''double''.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#double]], [[#float]], [[#int]], [[#short]]| [[.:beispiel:typen]]|
 +
 +==== mutable ====
 +C++98 : 
 +Als ''mutable'' (dt. veränderbar) gekennzeichnete 
 +[[begriffe#Attribut|Attribute]]
 +einer [[begriffe#Klasse]] 
 +können sich selbst dann ändern, wenn das [[begriffe#Objekt]] 
 +als konstant markiert ist oder eine konstante [[begriffe#Methode]]
 +abgearbeitet wird. 
 +Mit anderen Worten: ''mutable'' verletzt absichtlich die Regeln für ''const''.
 +Weil das schlecht ist, sollten zuvor andere Wege geprüft werden.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|     | [[#class]], [[#const]]| [[.:beispiel:mutable]]|
 +
 +==== namespace ==== 
 +C++98 : 
 +Das Schlüsselwort ''namespace'' erlaubt es,
 +die Verschmutzung des globalen 
 +[[begriffe#Namensraum|Namensraums]] 
 +mit Bezeichnern einzuschränken.
 +Kollisionen zwischen gleichartigen Bezeichnern in Bibliotheken
 +unterschiedlicher Hersteller werden dadurch vermieden.
 +Der Nutzer kann entscheiden, ob er 
 +
 +  *  mit dem Schlüsselwort [[#using]] einen ganzen Namensraum oder 
 +    * nur einzelne Bezeichner importieren oder
 +  *  die Bezeichner voll qualifiziert mit vorangestelltem Namensraumbezeichner ansprechen will.
 +
 +Alle Bezeichner der C++-Standard-Bibliothek befinden sich im Namensraum ''std''.
 +Im namenlosen Namensraum ''namespace {...}'' 
 +werden Bezeichner untergebracht, die nicht aus anderen Übersetzungseinheiten
 +zugreifbar sein sollen. (Der Einsatz von [[#static]]
 +für diesen Zweck ist wie in C möglich, 
 +wird jedoch im Standard ISO 14882:1998 missbilligt.)
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#using]]| [[.:beispiel:namespace]]|
 +
 +==== new ====
 +C++ : Der Operator ''new'' erzeugt dynamische Objekte.
 +Bei Erfolg liefert der Operator einen Zeiger 
 +auf einen vom System geborgten Speicherbereich.
 +Der Speicherplatz muss irgendwann (genau einmal!) mit [[#delete]]
 +wieder zurückgegeben werden. 
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#delete]], [[#nullptr]]| [[.:beispiel:new]]|
 +
 +==== noexcept ====
 +C++11 : Die Angabe ''nothrow'' nach der Parameterliste einer [[begriffe#Funktion]] oder [[begriffe#Methode]] zeigt an, dass diese keine [[begriffe#Ausnahme]] werfen wird. Sollte dies doch geschehen, wird das Programm mit der Ausnahme ''std::unexpected'' beendet.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#catch]], [[#throw]]| [[.:beispiel:noexcept]]|
 +
 +==== nullptr ====
 +C++11 : Wert für nicht zugewiesene Zeiger.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#delete]], [[#new]]| [[.:beispiel:new]]|
 +
 +==== operator ====
 +C++ : [[operator#Operatoren|Operatoren]]
 +sind über das Schlüsselwort ''operator'' 
 +auch als Funktionen ansprechbar.
 +Viele Operatoren lassen sich 
 +[[operator#overload|überladen]],
 +d.h. für neue, selbst definierte Datentypen 
 +([[begriffe#Klassen|Klassen]] 
 +und [[begriffe#Struktur|Strukturen]]) 
 +mit einer eigenständigen Bedeutung neu festlegen. 
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#class]], [[#struct]]| [[.:beispiel:operator]]|
 +
 +==== private ====
 +C++ : In als ''private:'' markierten Abschnitten einer 
 +[[begriffe#Klassendefinition]]
 +aufgeführte Bestandteile einer [[begriffe#Klasse]]
 +können nur in Methoden dieser Klasse benutzt werden.\\
 +
 +Private (heimliche) [[begriffe#Vererbung]]
 +macht die Schnittstelle einer [[begriffe#Basisklasse]]
 +nur innerhalb der abgeleiteten Klasse nutzbar.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#friend]], [[#protected]], [[#public]]| [[.:beispiel:class]]|
 +| | [[#class]], [[#struct]]|  [[.:beispiel:vererben]]|
 +
 +==== protected ====
 +C++ : In als ''protected:'' markierten Abschnitten 
 +einer [[begriffe#Klassendefinition]]
 +aufgeführte Bestandteile einer [[begriffe#Klasse]]
 +können nur in Methoden dieser und abgeleiteter Klassen benutzt werden.\\
 +
 +Geschützte [[begriffe#Vererbung]] 
 +macht die Schnittstelle und die geschützten Bestandteile 
 +einer [[begriffe#Basisklasse]] 
 +innerhalb der abgeleiteten Klasse nutzbar.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#friend]], [[#protected]], [[#public]]| [[.:beispiel:class]]|
 +| | [[#class]], [[#struct]]|  [[.:beispiel:vererben]]|
 +
 +==== public ====
 +C++ : In als ''public:'' markierten Abschnitten 
 +einer [[begriffe#Klassendefinition]]
 +aufgeführte Bestandteile einer [[begriffe#Klasse]]
 +sind öffentlich zugänglich.\\
 +
 +Durch öffentliche [[begriffe#Vererbung]] 
 +können Objekte auch als Objekte 
 +der [[begriffe#Basisklasse]]
 +angesprochen werden.   
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#friend]], [[#protected]], [[#public]]| [[.:beispiel:class]]|
 +| | [[#class]], [[#struct]]|  [[.:beispiel:vererben]]|
 +
 +==== register ====
 +C : Der Modifizierer ''register'' gibt dem Compiler die Empfehlung,
 +eine häufig genutzte Variable im Prozessorregister zu halten statt im Hauptspeicher.
 +Eine solche Optimierung kann z.B. für die innerste Schleife einen Geschwindigkeitsvorteil bringen.
 +
 +C++11 : Die Nutzung des Schlüsselwortes ist nun geächtet. 
 +
 +C++17 : Das Schlüsselwort wird nicht mehr benutzt, bleibt aber reserviert.
 +
 +==== reinterpret_cast ==== 
 +C++98 :  
 +Ein ''reinterpret_cast'' ist eine auffällige Form eines 
 +[[begriffe#Typecast]],
 +mit dem die Bitfolge eines Ausdruckswertes völlig anders interpretiert wird.
 +Diese andere Interpretation ist systemabhängig,
 +z. B. können die Bytes von Ganzzahlen auf verschiedenen Systemen
 +in unterschiedlicher Reihenfolge abgespeichert sein
 +(little endian, big endian).
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#const_cast]], [[#static_cast]]| [[.:beispiel:typecast]]|
 +
 +==== requires ====
 +C++20: stellt eine Anforderung an [[.:begriffe#Schablone]]n bzw. formuliert Anforderungen.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| [[kennen:concepts]] | [[#concept]] | [[.:beispiel:requires]]|
 +
 +==== return ====
 +C, C++ : Mit dem Schlüsselwort ''return'' wird die 
 +Rückkehr-[[begriffe#Anweisung]]
 +aus einer [[begriffe#Funktion]]
 +eingeleitet. Hat die Funktion nicht den Ergebnistyp [[#void]],
 +sollte nach ''return'' eine Ausdruck für den Ergebniswert folgen.
 +Anweisungen hinter der Rückkehranweisungen werden nicht abgearbeitet.
 +Die Funktion wird mit der ''return''-Anweisung unmittelbar verlassen.
 +Die Kontrolle wird an das Programmteil zurückgegeben, das die Funktion aufgerufen hat.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | -               | [[.:beispiel:funktion]]|
 +
 +==== short ====
 +C, C++ : Der Modifizierer ''short'' beim Datentyp [[#int]]
 +gibt einen Typ mit geringeren Speicherplatzbedarf
 +und kleinerem [[begriffe#Wertebereich]]
 +an.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|        | [[#int]], [[#long]]| [[.:beispiel:typen]]|
 +
 +==== signed ====
 +C, C++ : Der Typmodifizierer ''signed'' ist nur auf die ganzzahligen Typen [[#char]]
 +und [[#int]]
 +sowie auf dessen Modifikationen [[#short]]
 +und [[#long]]
 +anwendbar. Der Typ wird als vorzeichenbehaftet interpretiert.
 +Auf Systemen mit binärem Datenspeicher ist damit 
 +der größte darstellbare Wert nur etwa halb so groß
 +wie beim vorzeichenlosen ([[#unsigned]]) Typ,
 +dafür gibt es aber auch negative Werte.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#char]], [[#int]], [[#unsigned]]| [[.:beispiel:typen]]|
 +
 +==== sizeof ====
 +C, C++ : Mit dem Operator ''sizeof'' lässt sich der Speicherplatzbedarf 
 +von Typen und Variablen bestimmen.
 +Die Größenangabe erfolgt in Byte.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#typeid]]| [[.:beispiel:typen]]|
 +
 +==== static ====
 +C, C++ : Das Schlüsselwort ''static'' spielt mehrere unterschiedliche Rollen:
 +
 +  -  Statische lokale Variablen in [[begriffe#Funktion|Funktionen]] behalten ihren Wert auch zwischen den Funktionsaufrufen. Die Lebensdauer solcher Variablen erstreckt über das gesamte Programm. 
 +  -  Eine statische Variable in einer [[begriffe#Klasse|Klasse]] ist nur einmal für die gesamte Klasse vorhanden. Eine solche [[begriffe#Klassenvariable]] existiert unabhängig von der Anzahl von Objekten, die alle Zugriff auf diesen gemeinsamen Speicherplatz haben. Zum [[begriffe#Binden]] muss die Klassenvariable außerhalb der Klasse definiert werden. 
 +  -  Statische [[begriffe#Methode|Methoden]] können auch ohne existierende [[begriffe#Objekt|Objekte]] über ihren Klassennamen angesprochen werden. Statische Methoden dürfen nur statische Klassenvariablen nutzen. Die Klasse wirkt hier als Namensraum.
 +  -  Statische globale Funktionen und statische globale Variablen sind auf die Übersetzungseinheit (Quelltextdatei) beschränkt gültig. Solche Bezeichner sind für [[#extern]]-Deklarationen aus anderen Quelltextdateien nicht sichtbar. Einschließen in einen namenlosen Namensraum erreicht denselben Effekt.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#auto]], [[#extern]], [[#namespace]], [[#thread_local]]| [[.:beispiel:static]]|
 +==== static_assert ====
 +C++11 : Das neue Schlüsselwort ''static_cast'' erleichtert das Formulieren von Bedingungen, die zum Übersetzen notwendig sind.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | - | [[.:beispiel:static_assert]]|
 +
 +==== static_cast ====
 +C++98 : 
 +Ein ''static_cast'' ist eine auffällige Form eines 
 +[[begriffe#typecast|Typecast]],
 +mit dem eine zulässige Typumwandlung durchgeführt wird.
 +Der Effekt ist derselbe wie das Anlegen und Initialisieren 
 +einer temporären Variable vom Zieltyp.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#const_cast]], [[#reinterpret_cast]]| [[.:beispiel:typecast]]|
 +
 +==== struct ====
 +C, C++ : Das Schlüsselwort ''struct'' leitet die Deklaration bzw. 
 +Definition eines Verbunddatentyps 
 +([[begriffe#Struktur]]) ein,
 +der Daten unterschiedlicher Typen bündelt.
 +In C++ dürfen Strukturen, anders als in C, auch 
 +[[begriffe#Methode|Methoden]]
 +enthalten. Damit sind Klassen ([[#class]]) 
 +und Strukturen gleichwertig mit einer Ausnahme: 
 +Das voreingestellte [[begriffe#Zugriffsrecht]]
 +einer Struktur ist [[#public]].\\
 +
 +Seltener wird der Verbundtyp genutzt, um Teile einer Ganzzahl als 
 +[[begriffe#Bitfeld|Bitfelder]]
 +anzusprechen. Dieses Merkmal ist implementationsabhängig.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#class]]| [[.:beispiel:struct]]|
 +|                             | [[.:beispiel:ieee]]|
 +
 +==== switch ====
 +C, C++ : Der ganzzahlige Ausdruck nach dem Schlüsselwort ''switch'' 
 +entscheidet, welcher Fall ([[#case]]) einer 
 +[[begriffe#Mehrfachverzweigung]]
 +abgearbeitet wird. 
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#break]], [[#case]], [[#default]]| [[.:beispiel:switch]]|
 +| | [[#else]], [[#if]]| [[.:beispiel:ifelse]]|
 +
 +==== template ====
 +C++ : Als Schablonen (engl. templates) definierte 
 +[[begriffe#Funktionsschablone|Funktionsschablonen]]
 +und [[begriffe#Klassenschablone|Klassenschablonen]]
 +lassen Typen oder auch ganzzahlige Konstanten bis zur Nutzung offen.
 +Die Typ-Parametrisierung im generischen 
 +[[begriffe#Programmierstil]]
 +stellt eine statische Form von 
 +[[begriffe#Polymorphie]]
 +dar. 
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#typename]]  | [[.:beispiel:template]]|
 +
 +==== this ====
 +C++: Jedes [[begriffe#Objekt]]
 +kennt seine eigene Speicheradresse.
 +In Methoden kann mit dem Zeiger ''this'' 
 +auf das ausführende Objekt verwiesen werden.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | -               | [[.:beispiel:operator]]|
 +
 +==== thread_local ====
 +C++11 : Im Gegensatz zu ''static'' deklarierten Variablen werden ''thread_local''-Variablen für jeden Ablauffaden (Thread) nebenläufiger Programme unabhängig angelegt.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#static]]| - |
 +==== throw ====
 +C++98 : Das Schlüsselwort ''throw'' (dt. werfen) 
 +dient dazu, eine [[begriffe#Ausnahme]]
 +zu [[ausnahmen#werfen|werfen]] bzw. die Möglichkeit zu erklären.\\
 +
 +Eine ''throw''-Anweisung wirft eine Ausnahme.
 +Der normale Programmablauf wird abgebrochen.
 +Alle auf dem Stapel befindlichen Variablen werden abgebaut (stack unwinding),
 +bis ein passender [[#catch]]-Block zur 
 +[[begriffe#Ausnahmebehandlung]]
 +gefunden wird.
 +Wird eine Ausnahme nicht gefangen, endet das Programm mit einer 
 +(implementationsspezifischen) Fehlermeldung.\\
 +
 +Eine ''throw''-Deklaration im Funktionskopf bekennt,
 +welche Ausnahmen eine Funktion werfen kann.
 +Tritt eine Ausnahmesituation ein, die laut ''throw''-Deklaration
 +gar nicht eintreten dürfte, wird ein ''bad_exception''-Ausnahme ausgelöst.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#catch]], [[#try]]| [[.:beispiel:except]]|
 +
 +==== true ====
 +C++98 : Der Wahrheitswert ''true'' (dt. wahr) hat den Wert 1.
 +Das ist auch der Ergebniswert bei erfüllter logischer Testbedingung.
 +Wird einer [[#bool]]-Variable ein Wert ungleich 0 zugewiesen,
 +erhält diese Variable den Wert true.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|      | [[#bool]], [[#false]]| [[.:beispiel:bool]]|
 +
 +==== try ====
 +C++98 : 
 +Das Schlüsselwort ''try'' (dt. versuche) leitet einen Block ein,
 +der unsichere Anweisungen enthält,
 +die direkt oder indirekt eine [[begriffe#Ausnahme]]
 +werfen ([[#throw]]) können.
 +An den try-Block schliessen sich ein oder mehrere [[#catch]]-Blöcke an.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#catch]], [[#throw]]| [[.:beispiel:except]]|
 +
 +==== typedef ====
 +C, C++ : Das Schlüsselwort ''typedef'' weist einem existierenden Typ
 +oder einem davon abgeleiteten Typ einen neuen Namen zu. 
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | - | [[.:beispiel:typen]]|
 +| C++11 | [[#using]] | [[.:beispiel:using]]|
 +
 +==== typeid ====
 +C++98 : 
 +Der ''typeid''-Operator liefert ein ''std::typeinfo''-Objekt
 +zur Laufzeit-Typinformation (RTTI).
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | - | [[.:beispiel:typen]]|
 +
 +==== typename ====
 +C++98 : 
 +Das Schlüsselwort ''typename'' wurde eingeführt,
 +um dem Compiler in [[begriffe#Schablone|Schablonen]]
 +bekannt zu geben, dass der nachfolgende noch unbekannte Bezeichner ein Typ ist.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#template]]| [[.:beispiel:template]]|
 +
 +==== union ====
 +C, C++ : [[begriffe#Vereinigung|Vereinigungen]]
 +''union'' haben mehrere Komponenten
 +unterschiedlichen Typs, die sich einen Speicherplatz gemeinsam teilen,
 +d.h. je nachdem, über welchen Bezeichner der Speicher angesprochen wird,
 +wird dasselbe Bitmuster anders interpretiert.
 +Werden Daten eines Typs abgelegt und dann Daten eines anderen Typs gelesen,
 +so ist das Ergebnis implementationsspezifisch.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#struct]] | [[.:beispiel:union]]|
 +| | | [[.:beispiel:ieee]]|
 +
 +==== unsigned ====
 +C, C++ : Der Typmodifizierer ''unsigned'' ist nur auf die ganzzahligen Typen [[#char]]
 +und [[#int]]
 +sowie auf dessen Modifikationen [[#short]]
 +und [[#long]]
 +anwendbar. Der Typ wird als vorzeichenlos interpretiert.
 +Auf Systemen mit binärem Datenspeicher 
 +ist damit der größte darstellbare Wert etwa doppelt so groß
 +wie beim vorzeichenbehafteten ([[#signed]]) Typ,
 +dafür gibt es aber keine negativen Werte.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +| | [[#char]], [[#int]], [[#signed]]| [[.:beispiel:typen]]|
 +
 +==== using ====
 +C++98 : Mit dem Schlüsselwort ''using'' kann
 +der Nutzer einen ganzen 
 +[[begriffe#Namensraum]] ([[#namespace]]) 
 +oder auch nur einzelne Bezeichner importieren,
 +die er nicht mit vorangestelltem Namensraumbezeichner ansprechen will.
 +Alle Bezeichner der C++-Standard-Bibliothek befinden sich im Namensraum ''std''.
 +
 +C++11 : Das Schlüsselort ''using'' erlaubt die Einführung neuer Bezeichner für Datentypen. 
 +Generische Typ-Aliase gehen über die Möglichkeiten des Schlüsselwortes ''typedef'' hinaus.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#namespace]]| [[.:beispiel:namespace]]|
 +| C++11       | [[#typedef]] | [[.:beispiel:using]]|
 +
 +==== virtual ====
 +C++ : Als ''virtual'' gekennzeichnete [[begriffe#Methode|Methoden]]
 +werden eingerichtet, um sie in abgeleiteten Klassen zu überschreiben.
 +Werden solche Methoden dann über Zeiger oder Referenzen des 
 +[[begriffe#Basisklasse|Basisklassen-Typs]]
 +aufgerufen, wird die tatsächliche (engl. virtual) 
 +Methode des referenzierten Objekts
 +ausgeführt. Dieses Verhalten wird als 
 +[[begriffe#Polymorphie]]
 +bezeichnet.
 +
 +Virtuelle Basisklassen kommen bei der Nutzung der 
 +[[begriffe#Mehrfachvererbung]]
 +vor.
 +In der Klassenhierarchie kann ein gerichteter Graph entstehen (Rhombus), 
 +bei dem eine Basisklasse B auf mehreren Wegen (A1 und A2) an C vererbt wird.
 +Dadurch existieren mehrere Basisobjekte A1::B und A2::B in den C-Objekten.
 +Wird dagegen die Basisklasse ''virtual'' vererbt,
 +befindet sich nur eine Basisinstanz B im mehrfach abgeleiteten Objekt C.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#class]]| [[.:beispiel:vererben]]|
 +|                        | [[.:beispiel:virtual]]|
 +
 +==== void ====
 +C, C++ : Das Schlüsselwort ''void'' (dt. leer) steht dort, 
 +wo kein Typ angegeben werden kann.\\
 +
 +Funktionen mit dem [[begriffe#Rückgabetyp]]
 +''void'' liefern keinen Rückgabewert.\\
 +
 +Die Angabe ''void'' in der Parameterliste einer 
 +[[begriffe#Funktion]]
 +und die leere Parameterliste sind in C++ gleichbedeutend.\\
 +
 +Typfreie [[begriffe#Zeiger]]
 +''void*'' erlauben keine [[begriffe#Zeigerarithmetik]].
 +Sie halten eine Adresse, ohne dass gesagt werden kann,
 +wie die dort stehenden Bits zu interpretieren sind.
 +Dazu ist ein [[begriffe#Typecast]]
 +erforderlich.
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|       | [[#reinterpret_cast]]| [[.:beispiel:typen]]|
 +
 +==== volatile ====
 +C, C++ : Flatterhafte (engl. volatile) Variablen können ihre Werte auch ohne
 +Zuweisungen durch das Programm ändern, z. B. in einem Gerätetreiber.
 +Dem Compiler wird mit der Kennzeichnung ''volatile'' untersagt,
 +bei der Optimierung irgendwelche Annahmen über den Variablenwert zu machen.
 +Bei jedem lesenden Zugriff muss der Wert erneut ausgelesen werden, 
 +scheinbar überflüssige Schreiboperatoren dürfen ebenfalls nicht wegoptimiert werden.
 +
 +C++11 : In Multithreading-Anwendungen erfolgt Synchronisierung besser über ''std::atomic<T>'' oder Mutexe, da ''volatile'' keine Thread-Sicherheit garantiert.
 +
 +==== wchar_t ====
 +C++ :  Der implementierungsabhängige Datentyp ''wchar_t''
 +wird für Zeichensätze / Kodierungen mit mehr als 1 Byte Breite 
 +(Unicode / ISO 10646, UCS-2 / UTF-16, UCS-4 / UTF-32) benötigt.
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#char]], [[#char16_t]], [[#char32_t]]| [[.:beispiel:typen]]|
 +
 +==== while ====
 +C, C++ : Das Schlüsselwort ''while'' markiert die 
 +Durchführungs-[[begriffe#Bedingung]]
 +am Beginn einer
 +[[begriffe#kopfgesteuerte Schleife|kopfgesteuerten Schleife]]
 +bzw. am Ende einer mit [[#do]]
 +eingeleiteten [[begriffe#fußgesteuerte Schleife|fußgesteuerten Schleife]].
 +
 +
 +| Siehe auch: | Schlüsselwörter | Quelltext|
 +|             | [[#do]]| [[.:beispiel:while]]|
 +
 +
  
kennen/keywords.txt · Zuletzt geändert: 2020-07-18 12:24 von 127.0.0.1

Donate Powered by PHP Valid HTML5 Valid CSS Driven by DokuWiki