Syntax von Konstantendeklarationsanweisungen in C♯

Die Festlegung der Eigenschaften einer Konstanten nennt man auch „Deklaration einer Konstante“. Dabei bedeutet der Begriff Deklaration „Festlegung“.

Die Deklaration einer Konstanten erfolgt mit einer Konstantendeklarationsanweisung, für den wir schon Beispiele gesehen haben.

Eine Konstantendeklarationsanweisung (Beispiel)

const int zwoelf = 12;

Eine Konstantendeklarationsanweisung wird manchmal auch nur kurz als eine Konstantendeklaration bezeichnet, auch wenn dies nicht immer ganz korrekt ist, weil eine Konstantendeklaration eigentlich nur der Teil einer Konstantendeklarationsanweisung ist, der sich vor dem Semikolon befindet.

Unter einem Wertausdruck verstehen wir einen Ausdruck, der einen Wert hat. Es soll sich dabei also nicht um den Aufruf einer void-Methode handeln.

Eine Deklarationsanweisung zu einer Konstanten besteht aus dem Wort »const«, der Angabe des Typs der Konstanten (wie beispielsweise »string«, »int« oder »double«), einem Bezeichner als Namen der Konstanten, gefolgt von einem Gleichheitszeichen »=«, einem Wertausdruck (wie beispielsweise »12«) und einem Semikolon »;«.

Eine Konstantendeklarationsanweisung darf in einem Block überall dort verwendet werden, wo auch eine Anweisung stehen dürfte.

Konstantendeklarationsanweisung (Beispiele)

const int a = 12;
const double x = 2.724;
const string text = "abc";

Konstantendeklarationsanweisung (Syntaxdiagramm)

Konstantendeklarationsanweisung
    .-----------------------.     .-.
--->| Konstantendeklaration |--->( ; )--->
    '-----------------------'     '-'

Konstantendeklaration (vereinfachtes Syntaxdiagramm)

Konstantendeklaration
     .-----.     .-----.    .------------.     .-.     .----------.
--->( const )--->| Typ |--->| Bezeichner |--->( = )--->| Ausdruck |--->
     '-----'     '-----'    '------------'     '-'     '----------'
Typ
         .------.
---.--->( string )--->.--->
   |     '------'    ^
   |      .---.      |
   '---->( int )-----'
   |      '---'      |
   |     .------.    |
   '--->( double )---'
         '------'

Block (Syntaxdiagramm)

Anweisung.
     .-.                                   .-.
--->( { )----.----------------------.---->( } )---->
     '-'     |                      |      '-'
             |    .-----------.     |
             '----| Anweisung |<----'
                  '-----------'

Anweisung

Anweisung
        .---------------------------------.
---.--->| Aufrufanweisung                 |----.--->
   |    '---------------------------------'    |
   |    .---------------------------------.    |
   '--->| Block                           |----'
   |    '---------------------------------'    |
   |    .---------------------------------.    |
   '--->| Konstantendeklarationsanweisung |----'
        '---------------------------------'

Schlüsselwörter

Ein Schlüsselwort ist eine Bezeichnerzeichenfolge, die in den offiziellen Syntaxdiagrammen von C♯ als ein Terminalsymbol (und damit als eine lexikalische Einheit) erscheint.

Wir können aus dem Syntaxdiagramm „Konstantendeklaration“ vier Schlüsselwörter ablesen: »const«, »string«, »int« und »double«.

Konstantendeklaration (vereinfachtes Syntaxdiagramm)

Konstantendeklaration
     .-----.     .-----.    .------------.     .-.     .----------.
--->( const )--->| Typ |--->| Bezeichner |--->( = )--->| Ausdruck |--->
     '-----'     '-----'    '------------'     '-'     '----------'
Typ
         .------.
---.--->( string )--->.--->
   |     '------'    ^
   |      .---.      |
   '---->( int )-----'
   |      '---'      |
   |     .------.    |
   '--->( double )---'
         '------'

Leerraum in einer Konstantendeklaration

Der Typ einer final-Variablendeklaration muß vom folgenden Bezeichner durch Leerraum getrennt werden.

Hier fehlt Leerraum

const inta = 12;
const doublex = 2.724;
const stringtext = "abc";

Eine Implementation versucht beim Lesen von Quelltext immer möglichst lange lexikalische Einheiten zu bilden. Daher würde der Typ »int« mit einem ihm direkt folgenden Bezeichner »a« (dem Leerraum folgt) zu einer lexikalischen Einheit »inta« verbunden werden. Um dies zu verhindern, ist Leerraum hinter »int« notwendig.

Zwischen dem »a« und dem folgenden Gleichheitszeichen »=« in »final int a = 2;« wird jedoch kein Leerraum benötigt, da es keine Möglichkeit gibt, eine lexikalische Einheit »a« mit einem Gleichheitszeichen zu einer lexikalischen Einheit zu verbinden, da es in Java keine lexikalische Einheit gibt, die mit »a=« beginnt. Der ist vor dem Gleicheitszeichen »=« kein Leerraum nötig und die final-Variablendeklarationsanweisung »final int a= 2;« ist möglich.

Auch das Wort »const« muß vom folgenden Typ durch Leerraum getrennt werden.

Auch hier fehlt Leerraum

constint a = 12;
constdouble x = 2.724;
conststring text = "abc";

Allgemein müssen zwei Bezeichnerwörter immer durch Leerraum getrennt werden, wenn sie sonst direkt aufeinander folgen würden und nicht zu einem einzigen Bezeichnerwort verschmelzen sollen.

Der Initialisierungsausdruck

Der rechts vom Gleichheitszeichen stehende Wertausdruck wird als Initialisierungsausdruck bezeichnet.

ℛ Definition „Initialisierungsausdruck“ Der Initialisierungsausdruck einer Konstantendeklaration ist der Ausdruck direkt hinter dem Gleichheitszeichen »=«.

Der Initialisierungsausdruck muß kein Literal sein, auch konstante Ausdrücke sind erlaubt. Dabei verstehen wir unter einem konstanten Ausdruck ein Literale, eine Konstante oder einen Operatorausdruck, dessen Operanden konstante Ausdrücke sind.

Program.cs

public static class Program
{ public static void Main()
  { 
    const int a = 1;
    const int x = a;
    const int y = a + 1;
    global::System.Console.WriteLine( a );
    global::System.Console.WriteLine( x );
    global::System.Console.WriteLine( y );  }}

Protokoll

1
1
2

Wir kennen nun folgende Verwendungsmöglichkeiten von Ausdrücken: Ausdrücke können verwendet werden als

Operanden,
Argumente (in einem Aufruf oder einer Ausgabeanweisung), oder als
Initialisierungsausdrücke (neu).

Übungsfragen

? Übungsfrage

Was ist der Initialisierungsausdruck in dem folgenden Programm?

Program.cs

public static class Program
{ public static void Main()
  { 
    const int c = 2 + 1;
    global::System.Console.WriteLine( c );  }}

Protokoll

Übungsaufgaben

/ Inkarnieren von Syntaxdiagrammen

Schreiben Sie eine Inkarnation der Kategorie »Konstantendeklaration« des folgenden Syntaxdiagramms mit dem Typ »int«, dem Bezeichner »e« und dem Wertausdruck »8/2«.

Konstantendeklaration (vereinfachtes Syntaxdiagramm)

Konstantendeklaration
     .-----.     .-----.    .------------.     .-.     .----------.
--->( const )--->| Typ |--->| Bezeichner |--->( = )--->| Ausdruck |--->
     '-----'     '-----'    '------------'     '-'     '----------'
Typ
         .------.
---.--->( string )--->.--->
   |     '------'    ^
   |      .---.      |
   '---->( int )-----'
   |      '---'      |
   |     .------.    |
   '--->( double )---'
         '------'

„Deklaration“ oder „Definition“? *

Die Konstantendefinitionen werden nach der C♯ -Sprachspezifikation „Konstantendeklarationen “ genannt, nicht „Konstantendefinitionen “. Jedoch sprechen viele Programmierer auch manchmal von einer Definition einer Variablen oder von einer Variablendefinition.

Syntax einer Konstantenverwendung *

Für die Verwendung einer Konstanten als Ausdruck müssen wir keine neue Syntaxregel angeben, da wir schon früher behandelt haben, daß Namen, wie »global::System.Math.PI«, als Ausdrücke verwendet werden können.

Syntaxdiagramm

Ausdruck
    .-------.
--->| Name  |--->
    '-------'