Softwareentwicklung in C++ - ASC

48 2. Datentypen und Variablen
besitzen einen genau definierten Datentyp! Mit Preprocessor-Macros erreicht
man nur eine rein textuelle Ersetzung im Code, die keine Typensicherheit
bietet.
Wie man am folgenden Beispiel sehen kann, ist die Definition von Konstanten
völlig intuitiv (const_demo.cpp):
1 // const demo . cpp − a tiny demo program f o r the use o f
2 // typesafe constant d e f i n i t i o n s in C++
3
4 #include
5
6 const unsigned short RED PART = 0 ;
7 const unsigned short GREEN PART = 1;
8 const unsigned short BLUE PART = 2 ;
9
10 const unsigned short MAX COLOR INTENSITY = 0xFF ;
11 const unsigned short MIN COLOR INTENSITY = 0 x00 ;
12
13 int main ( int argc , char ∗ argv [ ] )
14 {
15 // constants do not need to be g l o b a l , the same
16 // r u l e s apply f o r the scope o f constants that
17 // are v a l i d f o r v a r i a b l e s in C++
18 const unsigned short NUM COLOR CHANNELS = 3;
19
20 unsigned short rgb value [NUM COLOR CHANNELS] ;
21
22 rgb value [RED PART] = MAX COLOR INTENSITY;
23 rgb value [GREEN PART] = MIN COLOR INTENSITY;
24 rgb value [BLUE PART] = MIN COLOR INTENSITY;
25
26 return ( 0 ) ;
27 }
Ich denke, es erübrigt sich, dieses Programm genau zu erklären. Allerdings
schaden ein paar kleine Anmerkungen vielleicht nicht:
• Wie der Name schon sagt, sind Konstanten unveränderbar. Also wird logischerweise
jeder Versuch, einer Konstante im Programm etwas zuzuweisen,
mit einem Compilerfehler enden.
• Konstanten müssen explizit auf einen Wert initialisiert werden. Vergisst
man die Initialisierung und schreibt z.B.
const unsigned short RED_PART;
so wird dies vom Compiler bemängelt. Dieses Verhalten ist auch logisch,
denn wozu sollte man eine Konstante brauchen, wenn sie dann vom Compiler
implizit auf 0 gesetzt werden soll?
• Im Gegensatz zu Preprocessor-Macros folgen Konstantendefinitionen in
C ++ den Scope-Regeln, die auch für Variablen gelten.
• Weil eine Konstante nicht änderbar ist, muss auch nicht unbedingt Speicherplatz
für sie reserviert werden. Der Compiler kann nach vorheriger
Überprüfung der Typenkompatibilität ihren Wert einfach einsetzen. Dies
hat zwei Konsequenzen: