Deklarierte Konstanten

Aus RAD Studio
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.

Echte Konstanten

Unter einer echten Konstante versteht man einen deklarierten Bezeichner, dessen Wert sich nicht ändern kann. Zum 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 identifier = constantExpression

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

Wenn constantExpression einen ordinalen Wert zurückgibt, kann der Typ der deklarierten Konstante über eine Wertumwandlung festgelegt werden. Zum 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 constantExpression.

  • Wenn es sich bei constantExpression 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 constantExpression eine reelle Zahl ist, hat er den Typ Extended. Ist der konstante Ausdruck 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, FixedUInt 

0
$FFFFFFFFFFFFFFFF

0
18446744073709551615

UInt64 

-$80
 $7F

-128
 127

ShortInt

Int8 

-$8000
 $7FFF

-32768
 32767

SmallInt

Int16 

-$80000000
 $7FFFFFFF

-2147483648
 2147483647

Integer

Int32, FixedInt 

-$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

Integertyp auf 32-Bit-Plattformen und 64-Bit-Windows

Zu 32-Bit-Plattformen zählen 32-Bit-Windows, OSX32, 32-Bit-iOS und Android.

Bereich der Konstante (hexadezimal) Bereich der Konstante (dezimal) Typ Äquivalenter Typ 
 -$80000000
 $7FFFFFFF

-2147483648
 2147483647

LongInt

Integer 

0
$FFFFFFFF

0
4294967295

LongWord

Cardinal

Integertyp auf 64-Bit-Plattformen

Zu 64-Bit-Plattformen gehört auch 64-Bit-iOS.

Bereich der Konstante (hexadezimal) Bereich der Konstante (dezimal) Typ Äquivalenter Typ 
-$8000000000000000
 $7FFFFFFFFFFFFFFF

-9223372036854775808
 9223372036854775807

LongInt

Int64 

0
$FFFFFFFFFFFFFFFF

0
18446744073709551615

LongWord

UInt64

Beispiele für Konstantendeklarationen: 

const
  Min = 0;
  Max = 100;
  Center = (Max - Min) div 2;
  Beta = Chr(225);
  NumChars = Ord('Z') - Ord('A') + 1;
  Message = 'Out of memory';
  ErrStr = ' Error: ' + 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


Diese 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.

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 mit 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. Zum Beispiel: 

resourcestring
  CreateError = 'Cannot create file %s';
  OpenError = 'Cannot open file %s';
  LineTooLong = 'Line too long';
  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  identifier: type = value

Dabei ist identifier ein gültiger Bezeichner, type ist jeder beliebige Typ mit Ausnahme von Dateitypen und Varianten, und value ist ein Ausdruck mit diesem Typ. Zum Beispiel: 

const Max: Integer = 100;

In den meisten Fällen muss value ein konstanter Ausdruck sein. Wenn für type 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 Komma getrennt angegeben. Zur Angabe der Werte müssen konstante Ausdrücke verwendet werden. Zum 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 Komma voneinander getrennt werden. Zum 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 ein Semikolon 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, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);
  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: Dec; 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. Zum 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 mit dem Typ 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 = 'Warning!';

Typisierte Konstanten mit Schreibzugriff

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

In diesem Fall können Sie mit Zuweisungsanweisungen den Wert von typisierten Konstanten wie bei initialisierten Variablen ändern. Zum 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

Abgerufen von „http://docwiki.embarcadero.com/RADStudio/Rio/d/index.php?title=Deklarierte_Konstanten&oldid=211811“