Deklarierte Konstanten

Aus RAD Studio (Deutsch)
Wechseln zu: Navigation, Suche

Nach oben zu Datentypen, Variablen und Konstanten - Index

Unter dem Begriff "Konstanten" werden verschiedene Sprachkonstrukte zusammengefasst. Es gibt numerische Konstanten wie die Zahl 17 und String-Konstanten wie "Hello world!". Numerische Konstanten werden auch einfach als Zahlen bezeichnet, String-Konstanten als Zeichen-Strings oder String-Literale. Jeder Aufzählungstyp definiert Konstanten, die den Werten des jeweiligen Typs entsprechen. Es gibt vordefinierte Konstanten wie True, False und nil. Es gibt aber auch Konstanten, die wie Variablen durch eine Deklaration erzeugt werden.

Deklarierte Konstanten sind entweder echte Konstanten oder typisierte Konstanten. Oberflächlich betrachtet besteht zwischen diesen beiden Konstantentypen kein großer Unterschied. Für ihre Deklaration gelten aber verschiedene Regeln, und sie werden für unterschiedliche Zwecke eingesetzt.

Inhaltsverzeichnis

Echte Konstanten

Unter einer echten Konstante versteht man einen deklarierten Bezeichner, dessen Wert sich nicht ändern kann. Beispiel: 

const MaxValue = 237;

Hier wird die Konstante MaxValue mit dem Integer-Wert 237 deklariert. Die Syntax für die Deklaration echter Konstanten lautet:

const Bezeichner = konstanterAusdruck

Dabei ist Bezeichner ein gültiger Bezeichner, und konstanterAusdruck ein Ausdruck, der vom Compiler ohne Ausführung des Programms ausgewertet werden kann.

Wenn konstanterAusdruck einen ordinalen Wert zurückgibt, kann der Typ der deklarierten Konstante über eine Wertumwandlung festgelegt werden. Beispiel: 

const MyNumber = Int64(17);

Diese Anweisung deklariert die Konstante MyNumber mit dem Typ Int64, die den Integer-Wert 17 zurückgibt. Wenn der Typ nicht auf diese Weise festgelegt wird, erhält die deklarierte Konstante den Typ von konstanterAusdruck.

  • Wenn es sich bei konstanterAusdruck um einen Zeichen-String handelt, ist die deklarierte Konstante mit jedem String-Typ kompatibel. Hat der Zeichen-String die Länge 1, ist er zusätzlich mit jedem Zeichentyp kompatibel.
  • Wenn konstanterAusdruck vom Typ Real ist, hat er den Typ Extended. Ist konstanterAusdruck ein Integer, hat er einen der in der folgenden Tabelle aufgeführten Typen.

Typen für Integerkonstanten :



Bereich der Konstante (hexadezimal) Bereich der Konstante (dezimal) Typ Aliase

0..$FF

0..255

Byte

UInt8

0..$FFFF

0..65535

Word

UInt16

0..$FFFFFFFF

0..4294967295

Cardinal

UInt32, LongWord

0..$FFFFFFFFFFFFFFFF

0..18446744073709551615

UInt64

-$80..$7F

-128..127

ShortInt

Int8

-$8000..$7FFF

-32768..32767

SmallInt

Int16

-$80000000..$7FFFFFFF

-2147483648..2147483647

Integer

Int32, LongInt

-$8000000000000000..$7FFFFFFFFFFFFFFF

-9223372036854775808..9223372036854775807

Int64



Nativer 32-Bit-Integertyp :



Bereich der Konstante (hexadezimal) Bereich der Konstante (dezimal) Typ Äquivalenter Typ

-$80000000..$7FFFFFFF

-2147483648..2147483647

NativeInt

Integer

0..$FFFFFFFF

0..4294967295

NativeUInt

Cardinal



Nativer 64-Bit-Integertyp :



Bereich der Konstante (hexadezimal) Bereich der Konstante (dezimal) Typ Äquivalenter Typ

-$8000000000000000..$7FFFFFFFFFFFFFFF

-9223372036854775808..9223372036854775807

NativeInt

Int64

0..$FFFFFFFFFFFFFFFF

0..18446744073709551615

NativeUInt

UInt64



Hier einige Beispiele für Konstantendeklarationen: 


const
  Min = 0;
  Max = 100;
  Center = (Max - Min) div 2;
  Beta = Chr(225);
  NumChars = Ord('Z') - Ord('A') + 1;
  Message = 'Zu wenig Speicher';
  ErrStr = ' Fehler: ' + Message + '. ';
  ErrPos = 80 - Length(ErrStr) div 2;
  Ln10 = 2.302585092994045684;
  Ln10R = 1 / Ln10;
  Numeric = ['0'..'9'];
  Alpha = ['A'..'Z', 'a'..'z'];
  AlphaNum = Alpha + Numeric;

Konstante Ausdrücke

Ein konstanter Ausdruck kann vom Compiler ohne Ausführung des Programms ausgewertet werden. Als konstante Ausdrücke können Zahlen, Zeichen-Strings, echte Konstanten, Werte von Aufzählungstypen und die speziellen Konstanten True, False und nil verwendet werden. Zulässig sind auch Ausdrücke, die sich aus diesen Elementen zusammensetzen und Operatoren, Typumwandlungen und Mengenkonstruktoren enthalten. In konstanten Ausdrücken können keine Variablen, Zeiger und Funktionsaufrufe verwendet werden. Eine Ausnahme bilden Aufrufe der folgenden, vordefinierten Funktionen:



Abs

High

Low

Pred

Succ

Chr

Length

Odd

Round

Swap

Hi

Lo

Ord

SizeOf

Trunc



Die Definition eines konstanten Ausdrucks wird in verschiedenen Bereichen der Syntaxdefinition von Delphi verwendet. Konstante Ausdrücke werden zur Initialisierung globaler Variablen, zur Definition von Teilbereichstypen, zur Zuweisung von Ordinalpositionen an Werte in Aufzählungstypen, zur Festlegung von Standardparameterwerten, zur Erstellung von case-Anweisungen und zur Deklaration von echten und typisierten Konstanten eingesetzt.

Hier einige Beispiele für konstante Ausdrücke: 


100
'A'
256 - 1
(2.5 + 1) / (2.5 - 1)
'Embarcadero' + ' ' + 'Developer'
Chr(32)
Ord('Z') - Ord('A') + 1

Ressourcenstrings

Ressourcenstrings werden als Ressource gespeichert und zu einer ausführbaren Datei oder Bibliothek gelinkt. Deshalb ist keine erneute Compilierung des Programms erforderlich, wenn ein Ressourcenstring geändert wird.

Ressourcenstrings werden wie echte Konstanten deklariert, wobei das Wort const durch resourcestring ersetzt wird. Der Ausdruck rechts neben dem Symbol = muss ein konstanter Ausdruck sein, der als Ergebnis einen String-Wert liefert. Beispiel: 


resourcestring
  CreateError = 'Datei %s kann nicht erstellt werden';
  OpenError = 'Datei %s kann nicht geöffnet werden';
  LineTooLong = 'Zeile zu lang';
  ProductName = 'Embarcadero Rocks';
  SomeResourceString = SomeTrueConstant;

Typisierte Konstanten

Typisierte Konstanten können im Gegensatz zu echten Konstanten auch Werte mit Array-, Record-, Zeiger- und prozeduralem Typ enthalten. Konstante Ausdrücke dürfen keine typisierten Konstanten enthalten.

Typisierte Konstanten werden folgendermaßen deklariert:

const Bezeichner: Typ = Wert

Dabei ist Bezeichner ein gültiger Bezeichner, Typ ist jeder beliebige Typ mit Ausnahme von Dateitypen und Varianten, und Wert ist ein Ausdruck des Typs. Beispiel: 

const Max: Integer = 100;

In den meisten Fällen muss Wert ein konstanter Ausdruck sein. Wenn für Typ ein Array-, Record-, Zeiger- oder prozeduraler Typ angegeben wird, gelten spezielle Regeln.

Array-Konstanten

Bei der Deklaration einer Array-Konstante werden die Werte der Array-Elemente in Klammern und durch Kommas getrennt angegeben. Zur Angabe der Werte müssen konstante Ausdrücke verwendet werden. Beispiel: 

const Digits: array[0..9] of Char = ('0', '1', '2', '3', '4', '5', '6', '7', '8', '9');

Diese Anweisung deklariert eine typisierte Konstante mit dem Namen Digits, die ein Zeichen-Array enthält.

Da nullbasierte Zeichen-Arrays oft nullterminierte Strings darstellen, können zur Initialisierung von Zeichen-Arrays Konstanten verwendet werden. Die obige Deklaration lässt sich folgendermaßen vereinfachen: 

const Digits: array[0..9] of Char = '0123456789';

Konstanten, die mehrdimensionale Arrays darstellen, werden deklariert, indem die Konstanten jeder einzelnen Dimension in Klammern gesetzt und durch Kommas voneinander getrennt werden. Beispiel: 


type TCube = array[0..1, 0..1, 0..1] of Integer;
const Maze: TCube = (((0, 1), (2, 3)), ((4, 5), (6,7)));

Hier wird ein Array namens Maze mit den folgenden Werten erstellt: 


Maze[0,0,0] = 0
Maze[0,0,1] = 1
Maze[0,1,0] = 2
Maze[0,1,1] = 3
Maze[1,0,0] = 4
Maze[1,0,1] = 5
Maze[1,1,0] = 6
Maze[1,1,1] = 7

Array-Konstanten dürfen auf keiner Ebene Dateitypen enthalten.

Record-Konstanten

Bei der Deklaration einer Record-Konstante geben Sie am Ende der Deklaration den Wert jedes Feldes in Klammern an. Die Angabe erfolgt in der Form Feldname: Wert, wobei die einzelnen Feldzuweisungen durch einen Strichpunkt voneinander getrennt werden. Die Werte müssen durch konstante Ausdrücke dargestellt werden. Die Reihenfolge der Felder muss der Reihenfolge bei der Deklaration des Record-Typs entsprechen. Wenn ein Tag-Feld vorhanden ist, muss dessen Wert angegeben werden. Enthält der Record einen varianten Teil, können Werte nur an die Variante zugewiesen werden, die durch das Tag-Feld angegeben ist.

Beispiele: 


type
  TPoint = record
     X, Y: Single;
  end;
  TVector = array[0..1] of TPoint;
  TMonth = (Jan, Feb, Mar, Apr, Mai, Jun, Jul, Aug, Sep, Okt, Nov, Dez);
  TDate = record
    D: 1..31;
    M: TMonth;
    Y: 1900..1999;
  end;
const
  Origin: TPoint = (X: 0,0; Y: 0.0);
  Line: TVector = ((X: -3,1; Y: 1.5), (X: 5.8; Y: 3.0));
  SomeDay: TDate = (D: 2; M: Dez; Y: 1960);

Record-Konstanten dürfen auf keiner Ebene Dateitypen enthalten.

Prozedurale Konstanten

Zur Deklaration einer prozeduralen Konstante geben Sie den Namen einer Funktion oder Prozedur an, die mit dem deklarierten Typ der Konstante kompatibel ist. Beispiel: 


function Calc(X, Y: Integer): Integer;
begin
  ...
end;

type TFunction = function(X, Y: Integer): Integer;
const MyFunction: TFunction = Calc;

Die prozedurale Konstante MyFunction kann dann in einem Funktionsaufruf eingesetzt werden: 

I := MyFunction(5, 7)

Prozeduralen Konstanten kann auch der Wert nil zugewiesen werden.

Zeigerkonstanten

Bei der Deklaration einer Zeigerkonstante muss diese mit einem Wert initialisiert werden, der vom Compiler (zumindest als relative Adresse) aufgelöst werden kann. Dies ist auf drei Arten möglich: mit dem Operator @, mit nil oder (bei PChar- oder PWideChar-Konstanten) mit einem String-Literal. Ist z.B. I eine globale Variable des Typs Integer, können Sie folgende Konstante deklarieren: 

const PI: ^Integer = @I;

Die Konstante kann vom Compiler aufgelöst werden, da globale Variablen Bestandteil des Codesegments sind. Dasselbe gilt für Funktionen und globale Konstanten: 

const PF: Pointer = @MyFunction;

Da String-Literale als globale Konstanten zugewiesen werden, können Sie eine PChar-Konstante mit einem String-Literal initialisieren: 

const WarningStr: PChar = 'Warnung!';

Typisierte Konstanten mit Schreibzugriff

In Delphi können typisierte Konstanten verändert werden, wenn die Compiler-Direktive ($J+} oder {$WRITEABLECONST ON} gesetzt ist.

In diesem Fall können Sie mit Zuweisungsanweisungen den Wert von typisierten Konstanten wie bei initialisierten Variablen ändern. Beispiel: 


        {$J+}
       const
             foo: Integer = 12;
       begin
             foo := 14;
       end.

Unterschiede zwischen typisierten Konstanten mit Schreibzugriff und initialisierten Variablen:

  • Typisierte Konstanten mit Schreibzugriff können global und lokal in Prozeduren, Funktionen und Methoden verwendet werden.
  • Initialisierte Variablen stehen nur als globale Deklarationen zur Verfügung.
  • Initialisierte Variablen verursachen bei der Verwendung in Prozeduren und Methoden Compilierfehler.

Siehe auch

Von „http://docwiki.embarcadero.com/RADStudio/2010/d/index.php?title=Deklarierte_Konstanten&oldid=107910“
In anderen Sprachen