Home » Object Pascal » Allgemeines über Variablen und Konstanten

Allgemeines über Variablen und Konstanten

Was sind Variablen?

Variablen sind jedem bekannt, der schon einmal Mathematik-Unterricht hatte. Variablen sind einfach dafür da, irgendwelche Daten (Eingaben, Berechnungsergebnisse usw.) im Arbeitsspeicher abzulegen. Über den Variablennamen kann man direkt auf den Wert zugreifen.
Heißen die Variablen in Mathe meist x oder y, sollte ein Programmierer solche Namen nicht verwenden. Sie erschweren die Lesbarkeit des Quellcodes sehr. Diese Erfahrung wird jeder schon einmal gemacht haben, der ein Programm mehrere Monate liegen gelassen hat, um es dann erneut anzugehen.
Wichtige Regel also: Variablen selbsterklärende Namen geben. Groß- und Kleinschreibung ist nicht von Bedeutung, jedoch dürfen nur Buchstaben (keine Umlaute!), Zahlen und der Unterstrich verwendet werden. Der Variablenname muss mit einem Buchstaben beginnen.

delphi2005plus_10.gif

Seit Delphi 2005 unterstützt der Delphi-Compiler den Unicode-Zeichensatz, so dass in Variablennamen auch beliebige Sonderzeichen verwendet werden können.

In dem Zusammenhang sollte auch auf die sog. ungarische Notation hingewiesen werden. Hierbei handelt es sich um einen Quasi-Standard. Einem Variablennamen wird dabei eine kurze Vorsilbe hinzugefügt, die beschreibt, was für Werte darin gespeichert werden können. Eine Integer-Variable „Length“ beispielsweise würde mit ungarischer Notation „nLength“ heißen. Im Delphi-Styleguide ist das jedoch nicht vorgesehen.

Datentypen

Bevor eine Variable verwendet werden kann, sollte man sich darüber im Klaren sein, welche Werte sie aufnehmen soll. Variablen sind also Platzhalter oder „Container“ für einen Wert, der Platz im Arbeitsspeicher belegt; der Datentyp ist dagegen der Bauplan, nach dem die Variable erstellt wird.
Folgendes sind die grundlegenden Datentypen in Delphi:

TypWertebereichBeispiel
Deklaration
Zuweisung
Integer (ganze Zahlen)-2147483648 bis 2147483647var zahl: integer;zahl:=14;
Real (Gleitkommazahlen)5.0 x 10324 .. 1.7 x 10308var zahl: real;zahl:=3.4;
String (Zeichenketten)ca. 231 Zeichenvar text: string;text:='Hallo Welt!';
Char (Zeichen)1 Zeichenvar zeichen: char;zeichen:='a';
Boolean (Wahrheitswert)true, falsevar richtig: boolean;richtig:=true;

Dies sind die Standardtypen, die generell verwendet werden können. Vor allem für Zahlen gibt es jedoch noch weitere Typen. Wenn z. B. sicher ist, dass nur ganze Zahlen von 1 bis 50 gespeichert werden sollen, so kann statt Integer auch der Typ Byte verwendet werden, der nur die Zahlen von 0 bis 255 aufnehmen kann. Das Gleiche gilt für reelle Zahlen. Die weiteren Typen sind unter „Reelle Typen“ bzw. „Integer-Typen“ in der Hilfe aufgeführt. Bei Strings gibt es einige grundlegende Unterschiede, weshalb Sie darüber einen extra Abschnitt finden.

Deklaration

Man kann eine Variable nicht einfach verwenden. Vorher muss sie dem Compiler bekannt gemacht werden, damit er beim Kompilieren entsprechende Typprüfungen durchführen kann. Diese Bekanntmachung nennt man Deklaration. Vor einer Deklaration wird das reservierte Wort var geschrieben. Als erstes kommt der Name der Variablen, hinter einem Doppelpunkt der Typ. Mehrere Variablennamen vom gleichen Typ können in einer Zeile, durch Kommata getrennt, stehen.
Beispiel:

var zahl1, zahl2, zahl3: integer;
 ergebnis: real;
 text, eingabe: string;

An folgenden Stellen im Code ist das möglich, je nach Gültigkeitsbereich:

Globale Variablen

Bei manchen Programmierern sind sie verpönt, trotzdem sind sie möglich: globale Variablen. Ihr Wert ist in der gesamten Unit verfügbar und in allen Units, die diese einbinden. Die Deklaration erfolgt am Anfang der Unit:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs;

type
  TForm1 = class(TForm)
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;
  einezahl: integer;  // Diese Variable gilt in der ganzen Unit und
      // in allen Units, die diese Unit einbinden

implementation

{$R *.DFM}

var eine_andere_zahl: real; // Diese Variable gilt nur in dieser Unit

Globale Variablen können bei ihrer Deklaration mit einem Startwert belegt werden:

einezahl: integer = 42;
Diese Art der Zuweisung verwendet ein einfaches Gleichheitszeichen, nicht := Bei lokalen Variablen ist diese Initialisierung nicht möglich.

Lokale Variablen

Das Gegenstück zu globalen Variablen sind die lokalen. Hierbei wird eine Variable zu Beginn einer Prozedur, Funktion oder Methode deklariert. Sie kann somit nur innerhalb dieses Abschnitts verwendet werden. Wird die Prozedur/Funktion verlassen, dann wird der Speicher für die Variablen wieder freigegeben, d. h. auf die Werte kann nicht mehr zugegriffen werden. So könnte eine lokale Variablendeklaration aussehen:

procedure IchMacheIrgendwas;
var text: string;
begin
  ... //Irgendwas Sinnvolles
end;

Initialisierung

Bevor auf eine Variable zugegriffen wird, sollte sie initialisiert werden, es sollte ihr also ein Anfangswert zugewiesen werden. Strings enthalten zwar einen leeren String; alle anderen Variablentypen enthalten jedoch irgendwelche zufälligen Werte.

Zuweisungen

Zuweisung von Werten an eine Variable erfolgt in Pascal durch die Symbolfolge := („ergibt sich aus“). Im Gegensatz zur Mathematik ist deshalb auch Folgendes möglich:

x := x + 1;
Das Laufzeitsystem berechnet hier die Summe von x und 1 und legt das Ergebnis dann wieder in x ab. x ergibt sich aus dem bisherigen x plus 1. Kurz: x wird um 1 erhöht. Für diesen Fall gibt es auch eine eigene Prozedur: inc(x).

Typumwandlung

Im Gegensatz zu einigen anderen Sprachen ist Delphi bei Typen sehr streng. Es ist also nicht möglich, einer Integer-Variable eine Gleitkommazahl-Variable zuzuweisen. Dafür steht eine große Auswahl an Konvertierungsfunktionen zur Verfügung:

vonnachFunktionBeispiel
IntegerRealkein Problem, einfache Zuweisungvar zahl1: integer;
zahl2: real;
begin
zahl2 := zahl1;
RealIntegerMöglichkeiten:
- Nachkommastellen abschneiden (trunc)
- kaufm. Runden (round)
- aufrunden (ceil, Unit Math)
- abrunden (floor, Unit Math)
var zahl1: real;
zahl2: integer;
begin
zahl2 := trunc(zahl1);
zahl2 := round(zahl1);
IntegerStringIntToStrvar textzahl: string;
zahl: integer;
begin
textzahl := IntToStr(zahl);
RealStringFloatToStr
FloatToStrF
var textzahl: string;
zahl: real;
begin
textzahl := FloatToStr(zahl);
StringIntegerStrToInt
StrToIntDef
var textzahl: string;
zahl: Integer;
begin
zahl := StrToInt(textzahl);
StringRealStrToFloatvar textzahl: string;
zahl: real;
begin
zahl := StrToFloat(textzahl);
StringCharZugriff über Index
(1 ist erstes Zeichen)
var text: string;
zeichen: char;
begin
zeichen := text[1];
CharStringkein Problem, einfache Zuweisungvar zeichen: char;
text: string;
begin
text := zeichen;

Anzeigen

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *

Fragen und Anregungen können gerne im Forum gepostet werden. Die hierfür vorgesehene Sparte ist Delphi-Treff>>Feedback.