Konstantendefinitionen in C++

Durch eine Konstantendefinition wird ein Name für einen Wert  eines bestimmten Datentyps festgelegt.

Eine Konstantendefinition beginnt mit der Angabe des Datentyps und der Kennzeichnung "const", es folgt der zu definierende Name und der eingeklammerte Wert.

Eine Konstantendefinition

int const monate( 12 );

Anordnung von "const"

Das Schlüsselwort "const" kann auch vor den Datentyp geschrieben werden.

Eine Konstantendefinition (Variante 1)

const int monate( 12 );

Es handelt sich bei obiger Konstantendefinition nämlich um eine 〈simple-declaration 〉. Das Schlüsselwort "const" und das Schlüsselwort "int" gelten als 〈decl-specifier 〉 und für diese 〈decl-specifier 〉 am Anfang einer 〈simple-declaration 〉 ist kein bestimmte Reihenfolge vorgeschrieben.

Eine Konstantendefinition (Variante 1 mit Erklaerungen)

  .-------------------- <decl-specifier> 
  |    .--------------- <decl-specifier> 
  |    |       .------- <init-declarator> 
  |    |       | 
----- --- ------------ 
const int monate( 12 );

Die Schreibweise kann auch den folgenden Produktionen entnommen werden, die gegenüber der C++ -Norm vereinfacht wurden.

〈simple-declaration 〉 ::=

〈decl-specifier 〉 {〈decl-specifier 〉} [〈init-declarator 〉 {"," 〈init-declarator 〉}] ";".

〈decl-specifier 〉 ::=

"bool" | "int" | "double" | "const" | "extern".

〈init-declarator 〉 ::=

〈declarator 〉 [〈initializer 〉].

Die Schreibweise mit nachgestelltem "const" ist wahrscheinlich zu bevorzugen, da dadurch bestimmten Mißverständnisse in Zusammenhang mit definierten Typnamen vermieden werden und eine einheitliche Leseweise verwendet werden kann, die in C++  immer vom definierten Bezeichner nach außen erfolgt: "int const monate"—„monate ist ein konstanter int-Wert.“.

Angabe des Werts

Ein Initialisierer kann mit einer runden Klammer auf oder mit einem Gleichheitszeichen beginnen.

〈initializer 〉 ::=

〈direct-initializer 〉 | 〈copy-initializer 〉.

〈direct-initializer 〉 ::=

"(" 〈assignment-expression 〉 ")".

〈copy-initializer 〉 ::=

"=" 〈assignment-expression 〉.

Die Initialisierung mit runden Klammern ist eine Direkt-Initialisierung und die Initialisierung mit einem Gleichheitszeichen eine Kopier-Initialisierung.

Es gibt bestimmt Fälle, in denen ein Direkt-Initalisierer oder ein Kopier-Initialisierer verwendet werden muß. Bei den hier behandelte Initialisierungen von Konstanten einfacher Datentypen, sind beide Schreibweisen möglich und bedeuten auch beide das gleiche.

<init-declarator> mit Direkt-Initialisierer

  .----------- <declarator> 
  |      .---- <initializer> 
  |      | 
------ -------  
monate (  12 )

<init-declarator> mit Kopier-Initialisierer

  .----------- <declarator> 
  |      .---- <initializer> 
  |      | 
------ -----  
monate =  12

Die Schreibweise mit den runden Klammern führt auch manchmal zu Texten, die unbeabsichtigterweise eine Funktion deklarieren und keine Konstante definieren und muß auch dann abgewandelt werden, damit sie als Konstantendefinition erkannt wird.

Mehrere Deklaratoren in einer Deklaration *

Durch Komma getrennt können mehrere Init-Deklaratoren zu einem Kombination von Deklarationsspezifizierern angegeben werden.

Zwei int-Konstanten mit einer Deklaration

 .-------------------------------- <decl-specifier> 
 |    .--------------------------- <decl-specifier> 
 |    |       .------------------- <init-declarator> 
 |    |       |             .----- <init-declarator> 
 |    |       |             | 
--- ----- ------------  ---------- 
int const monate( 12 ), tage( 7 );

Die Deklaration "int const monate( 12 ), tage( 7 );" hat die Wirkung der beiden Deklarationen "int const monate( 12 ); int const tage( 7 );". In bestimmten Fällen kann die Vereinbarung mehrerer Konstanten mit einer Deklaration zu Mißverständnissen führen, so daß im Zweifel mehrere einzelne Deklaration gewählt werden sollten.