KAPITEL 2
Lexikalische Elemente
Auf der fundamentalsten Ebene besteht ein C++-Programm aus einzelnen lexikalischen Elementen, sogenannten Token. Token sind logisch zusammenhängende Einheiten, die durch den Lexer gebildet werden, indem er den Textstrom in einen Tokenstrom zerlegt. Token werden in der Regel durch Leerraum (Leerzeichen, Zeilenwechsel, Tabulatoren usw.) voneinander abgegrenzt, können aber auch gebildet werden, wenn der Start des nächsten Tokens erkannt wird. Dies ist in dem nächsten Beispiel schön zu sehen:
Dieser Tokenstrom besteht aus drei Token: ival, + und 3. Wenn kein Leerraum vorhanden ist, bildet der Compiler die Token, indem er von links nach rechts nach der längstmöglichen logischen Einheit sucht.
Die Token werden an den Parser übergeben. Dieser bestimmt, ob der Tokenstrom die korrekte Syntax besitzt. Zusammen bilden die Token komplexere semantische Konstrukte wie Deklarationen, Ausdrücke und Anweisungen, die sich auf den Ausführungsfluss auswirken.
Kommentare
Kommentare sind Anmerkungen im Quellcode. Sie richten sich an Entwickler und werden vom Compiler vollständig ignoriert. Sie werden in Leerzeichen konvertiert.
Ein Kommentar ist ein beliebiger Textblock, der entweder in /* und */ eingeschlossen wird oder hinter zwei Schrägstrichen (//) auf einer einzelnen Zeile folgt. Kommentare der ersten Form können nicht ineinander verschachtelt werden. Sie erstrecken sich gerne über mehrere Zeilen:
/* Dieser Kommentar hat mehr als eine Zeile.
Hier ist ein weiterer Teil des Kommentars.*/
Kommentare der zweiten Form sind nützlich für kurze Erläuterungen, die nicht mehr als eine einzige Zeile benötigen:
z = MIN(x, y); // z ist der kleinste Wert.
Wenn ein einzeiliger Kommentar beginnt, erstreckt er sich bis zum Ende der Zeile. Es gibt keine Möglichkeit, den Kommentar vorher zu beenden.
Bezeichner
Bezeichner in C++ sind Zeichenfolgen, die als Namen von Variablen, Funktionen, Parametern, Typen, Sprungmarken, Namensräumen und Präprozessormakros verwendet werden. Bezeichner können aus Buchstaben, Ziffern und Unterstrichen bestehen, dürfen aber nicht mit einer Ziffer beginnen. Die folgenden Zeichenketten sind allesamt zulässige C++-Bezeichner:
i addressBook Mgr item_count
ptr2 NAME_LENGTH class_ showWindow
Folgende Regeln gelten für Bezeichner:
- Bei Bezeichnern wird zwischen Groß- und Kleinschreibung unterschieden.
- Bezeichner dürfen nicht identisch mit reservierten Schlüsselwörtern in C++ sein.
- Bezeichner, die mit einem Unterstrich anfangen, sind für die Sprachimplementierung reserviert.
- Obwohl C++ selbst keine Größenbegrenzungen für Bezeichner vorsieht, besitzt jeder Compiler und Linker Größenbegrenzungen, die in der Praxis relevant sein können.
| Es gibt keine einheitlichen Stilkonventionen für Bezeichner. Viele Programmierer setzen aber Namen, die mit Kleinbuchstaben beginnen, für lokale Variablen, Instanzvariablen und Funktionen ein. Namen, die mit Großbuchstaben beginnen, werden dementsprechend für Typen, Namensräume und globale Variablen verwendet. Namen, die der Präprozessor verarbeitet, und Konstanten werden ganz in Großbuchstaben geschrieben. |
Reservierte Schlüsselwörter
C++ definiert eine Reihe von Schlüsselwörtern und alternativen Token. Dies sind Zeichenfolgen mit besonderer Bedeutung in der Sprache. Diese Wörter sind reserviert und können nicht als Bezeichner verwendet werden. Die reservierten Schlüsselwörter in C++ lauten:
alignas
alignof
and
and_eq
asm
auto
bitand
bitor
bool
break
case
catch
char
char16_t
char32_6
class
compl
const
constexpr
const_cast
continue
decltype
default
delete
do
double
dynamic_cast
else
enum
explicit
export
extern
false
final
float
for
friend
goto
if
inline
int
long
mutable
namespace
new
noexcept
not
not_eq
nullptr
operator
or
or_eq
override
private
protected
public
register
reinterpret_cast
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
xor
xor_eq
Literale
Literale sind lexikalische Elemente, die explizite Werte in einem Programm repräsentieren. C++ definiert viele verschiedene Typen von Literalen, die alle unter ihrem jeweiligen Typ im Abschnitt »Fundamentale Typen« auf Seite 45 beschrieben werden. Darüber hinaus kennt C++ Funktionsliterale, die auch als Lambda-Funktionen bezeichnet werden.
Benutzerdefinierte Literale
Benutzerdefinierte Literale sind selbst definierte Literale. Diese werden in C++ für ganze Zahlen, Fließkommazahlen, C-Strings und auch Zeichen unterstützt. Für sie gilt die folgende Syntax: Built-in-Literal + _ + Suffix. Das Suffix stellt in der Regel eine Einheit dar:
101000101_b
63_s
10345.5_dm
123.45_km
100_m
131094_cm
33_cent
"Hallo"_i18n
Benutzerdefinierte Literale erlauben es, Werte direkt mit ihrer Einheit zu verknüpfen. Damit lassen sich Operanden in C++ implementieren, die bei Operationen ihre Einheit berücksichtigen: Dist myDis= 10345.5_dm + 123.45_km – 100_m + 131094_cm. Die C++-Laufzeitumgebung bildet die benutzerdefinierten Literale auf die entsprechenden Literaloperatoren ab (siehe Abschnitt »Operatoren überladen« auf Seite 146). Diese müssen vom Programmierer implementiert werden. So definiert in dem folgenden Beispiel der Namensraum Unit alle Literaloperatoren, die für das richtige Interpretieren des arithmetischen Ausdrucks Dist myDis= 10345.5_dm + 123.45_km – 100_m + 131094_cm benötigt werden. In Kombination mit der Klasse Dist, die einen Konstruktor, einen Plus- und einen Minusoperator anbietet, lässt sich der ganze Ausdruck evaluieren. Dist verwendet als Einheit cm:
class Dist{
public:
explicit Dist(double i):cm(i){}
friend Dist operator +(const Dist& a, const Dist& b){
return Dist(a.cm + b.cm);
}
friend Dist operator -(const Dist& a, const Dist& b){
return Dist(a.cm - b.cm);
}
private:
double cm;
};
namespace Unit{
Dist operator "" _km(long double d){
return Dist(100000 * d);
}
Dist operator "" _m(long double m){
return Dist(100 * m);
}
Dist operator "" _dm(long double d){
return Dist(10 * d);
}
Dist operator "" _cm(long double...
