So nun zum nächsten teil, den Variablen:
[Inhalt]
1. Was sind Variablen
2. Typen
3. Verwendung
3.1 Konstanten
4. Verrechnen/Verknüpfen
5. Umwandlung
[Was sind Variablen]
Zu erst zur theorie (wer schon in anderen programmiersprachen programmiert hat einfach zum nächsten springen).
Spoiler anzeigen
In der Programmierung werden variablen und Konstanten verwendet um werte im Ram zu speichern. In variablen kann man über die zeit verschiedene werte speichern, wärend Konstante einen festen vordefinierten wert haben.
Die Theorie ist ganz einfach: Die Variable ist ein Name in deinem programm mit einer Adresse drin, unter welcher sich der entspechende wert finden lässt.
Ich gebe mal ein bsp (Nicht das mit den Karteien was jedes buch verwendet): Der Ram (Random Acess Memory) ist eine große Fläche, wenn du eine Variable erstellst kommt auf diese Fläche irgendwo ein Paket mit dem Inhalt dieser Variable. Auf einen Block schreibst du dir nun die genaue Position. Wenn nun verschiedene Programme verschiedene Variablen erstellen ist diese Fläche bald sehr voll und unübersichtlich. Willst du nun an den ihnalt deines Paketes musst du natürlich nicht jedes Paket öffnen und nachsehen, sondern siehst einfach auf deinen zettel und gehst an die entsprechende Position.
Ziemlich genau so macht das auch Delphi. Eine Variable Besteht im Wesentlichen aus 3 Teilen: Dem Namen, unter dem Delphi diese erkennt, der Ram Adresse: Der Ort an dem dieses "Informationspaket" liegt, und der Information um welchen Typen es sich handelt(Dazu gleich mehr).
Also banal gesagt: Mit variablen speicherst du was unter einem gewissen Namen.
Auch der Name variable kommt nicht von irgendwo, wie der Name sagt ist der Wert Variabel, und kann somit stetig verändert werden. Im gegensatz dazu gibt es noch sogenannte Konstanten, diese haben einen wert, und werden verwendet um einfach diesen werten Namen zum abrufen zu geben.
[Typen]
Delphi ist (Schon seit Pascal) Typ "Streng", das bedeutet, das man zu jeder Variable den Typen angeben muss. eine weitere Typ strenge sprache ist z.b. C.
Viele Programmierer aus den Script sprachen, sowie aus einigen Basics werden sich erst einmal umgewöhnen müssen, und werden sich warscheinlich auch fragen warum die "Richtigen" sprachen solche typangaben Brauchen.
Die Antwort ist recht simpel: Der Computer ist Stroh Dumm. Wenn dem Computer ein wert vor liegt kann dieser nicht erkennen wie er diesen verwenden soll.
Sollte im ram der wert 41h (hex) vorliegen so weiss der PC Nicht ob er eine zahl (64) oder einen Buchstaben ("A") zurückgeben soll.
Programmiersprachen wie PHP oder JS lösen das ganze so indem sie einfach anhand des Speicher Musters dies auswerten. So weisen texte ein anderes Muster als Zahlen auf.
Das hat zwar den Vorteil das es für den Programmierer leichter ist, allerdings 2 große Nachteile:
1. Die erkennung dieses Speicher musters braucht Zeit (Und die ist wertvoll)
2. Kann es immer mal wieder zu fehlern kommen (Meist durch unsaubren code) welche der Compiler nicht erkennen kann.
Also muss es Typen geben, Hier mal die wichtigsten:
Zu erst die Integral typen (Ganzzahlen):
Byte: von 0 bis 255 Benötigt 1 Byte (8 bit) Im Ram
Smallint: von -32768 bis 32767 Benötigt 2 Byte (16 bit) Im Ram
Word: von 0 bis 65535 Benötigt 2 Byte (16 bit) Im Ram
Integer: von -2147483648 bis 2147483647 Benötigt 4 Byte (32 bit) im Ram
LongWord: von 0 bis 4294967295 benötigt 4 Byte (32 bit) im Ram
Cardinal: von 0 bis 4294967295 benötigt 4 Byte (32 bit) im Ram
Spoiler anzeigen
Word und LongWord sind Unsigned, das heist sie haben keinen negativen bereich, dafür einen doppelt so großen positiven bereich
Nun zu den (Fließ)Kommazahlen:
Single: von 1.5 x 10^–45 bis 3.4 x 10^38 Benötigt 4 Byte (32 bit) im Ram 8 kommastellen genauigkeit
Real: von 5.0 x 10324 bis 1.7 x 10308 Benötigt 8 Byte (64 bit) im Ram 16 kommastellen genauigkeit
Extended: von -3,6 x 104951 bis 1,1 x 104932 benötigt 10 Byte (80 bit) im Ram 20 kommastellen genauigkeit
Spoiler anzeigen
Hinweis:
Durch den "Komischen" speicherverbrauch von extended hat dieser wert zwar einen großen bereich und ist sehr genau, aber für den PC schwer zu verwenden und ist Langsam
Weitere sind:
String: Text Datentyp, Kann bis zu 2 gb groß sein (2147483646 zeichen) Speicherverbrauch: Pro zeichen ein byte +1 byte
Boolean: Vergleichsdatentyp kann die werte True (Ja) und False (Nein) enthalten. Benötigt 1 bit und ist somit der kleinste daten typ
Char: Ein ASCII Zeichen, Benötigt 1Byte (8 bit) im Ram
Typen/Objekte: Im OOP werden Objekte wie TStringList über variablen angesprochen, seht ihr irgendwann mal sowas wie
Var SList: TStringList;
nicht wundern, man benötigt in diesem Fall SList nicht um was zu speichern sondern um eine TStringList zu verwenden
Da es als anfänger erst mal egal ist wie viel speicher welche variable verbraucht merkt euch einfach: Bei Ganzzahlen Integer, bei Text String, bei Komma zahlen Real.
Spoiler anzeigen
Später sollte man vor allem für größere Projekte drauf achten nicht mehr speicher als nötig zu verwenden hierzu ein kleines BSP:
Die entwickler von Star Craft 2 wussten das es im regulären spiel eigentlich unmöglich ist mehr als 200 einheiten zu besitzen, so haben sie als variable für die derzeit ausgewählten einheiten den type Byte verwendet, da man sowiso (ausser bei Marine arena) nie mehr als 255 Truppen gleichzeitig steuert.
Die genies von Crytek hätten warscheinlich extended verwendet.
[Verwendung]
Variablen werden in Delphi ganz eigen Definiert. Eine Definiton sieht so aus:
Var VariablenName: Type;
bsp:
Var MeinName: String;
im gegensatz zu anderen sprachen kann man das nicht einfach in den quelltext schreiben, in Delphi haben variablen eine feste Position.
Wenn man auf z.b. einem Button oder so Doppelt klickt so zeigt der code Editori sowas an:
procedure TForm1.Button1Click(Sender: TObject);
begin
end;
Damit haben wir auch das Letzte mal gearbeitet, dabei handelt es sich um eine Prozedur, einen "Block" der Code Enthält. Dieser code wird ausgeführt wenn ein ereignis geschieht (z.b. Button1 geklickt wird).
Eine solche Prozedur wird mit
procedure ObjektName.ProzedurName(Variablen);
eingeleitet
danach folgt ein begin, was bedeutet das ab da der Code anfängt der ausgeführt wird. mit end; wird das ganze abgeschlossen.
die variablen kommen zwischen das procedure ObjektName.ProzedurName(Variablen); und das Begin
BSP:
procedure TForm1.Button1Click(Sender: TObject);
var Variable1: String;
var Variable2: Integer;
var Variable3: Real;
begin
end;
Somit können die Variablen im code zwischen Begin und end; verwendet werden.
WICHTIG!!!!! Die variablen die du für den Block procedure TForm1.Button1Click(Sender: TObject); definierst kannst du auch nur in diesem Block verwenden, In anderen blöcken NICHT !!!!!
Spoiler anzeigen
Zwei Kleine Tipps:
Man muss nicht jedes mal ein var davor schreiben, wenn ein mal ein Var da steht weiß delphi das die Folgenden auch variablen sind.
also
procedure TForm1.Button1Click(Sender: TObject);
var
Variable1: String;
Variable2: Integer;
Variable3: Real;
begin
end;
ist das selbe wie oben.
2. Wenn man verschiedene Variablen eines Typs hat muss man nicht
Var1:String;
Var2:String;
schreiben sondern kann einfach
var Var1, Var2: String;
schreiben
Nun kann man ihnen werte zuweisen, das geht wie beim normalen code zwischen dem begin und end; also in der eigentlichen prozedur.
procedure TForm1.Button1Click(Sender: TObject);
var Variable1: String;
Variable2: Integer;
Variable3: Real;
begin
Variable1:='Hallo Welt';
Variable2:=2;
Variable3:=32.21;
end;
Wie im Letzten Tutorial erwähnt muss hier wieder das := hin, da den variablen ja ein wert zugewisen wird, also der wert gesetzt wird.
Das Abrufen der Variablen geht auch ganz einfach:
procedure TForm1.Button1Click(Sender: TObject);
var Variable1: String;
Variable2: Integer;
Variable3: Real;
begin
Variable1:='Hallo Welt';
Variable2:=2;
Variable3:=32.21;
Self.Caption:=Variable1;
end;
Damit sage ich einfach nur das der Text aus Variable1 in die Form1.Caption geschrieben werden soll
Die Form Caption ist der Name des Fensters.
[Konstanten]
Spoiler anzeigen
Konstanten Funktionieren fast genauso wie variablen, nur ihr wert muss während der Definition angegeben werden.
Variablen werden Mit dem Schlüsselwort Var Eingeleitet, Konstanten mit dem wort Const:
procedure TForm1.Button1Click(Sender: TObject);
const pi: Real=3.14159265;
r: Integer=2;
var u: Real;
begin
u:=pi*2*r;
end;
WICHTIG: Konstanten benötigen kein := sondern ein reines =
Eine kleine erklärung: ich setzte 2 Konstanten, einmal pi mit 3.14... und r mit 2.
und dann noch eine Variable u, welches der Umfang eines kreises sein soll der dann mit den beiden Faktoren errechnet werden soll.
Sowas wie pi wäre eine typische anwendungssituation von Konstanten.
und damit bin ich direkt schon im nächsten Kapitel
[Verrechnen/Verknüpfen]
Wie grad eben gesehen habe ich mit Variablen und Konstanten gerechnet.
Das ist eigentlich das wichtigste einsatzgebiet von Konstanten und Variablen.
Für das rechnen will ich nicht allzu viel zeit vertrödeln, also die kurz form:
Wenn man 2 Variablen hat, beides Zahlen typen (egal ob Float(Komma) oder Integral(Ganzzahl)) kann man diese ganz einfach verrechnen:
procedure TForm1.Button1Click(Sender: TObject);
var Ergebnis: Real;
Summand1: Integer;
Summand2: Real;
begin
Summand1:=2;
Summand2:=32.21;
Ergebnis:=Summand1+Summand2;
end;
Damit setzte ich auf ergebnis einen neuen wert, welcher eine Addition von Summand1 und Summand2 ist.
Als Additionssymbol(Additionsoperator) wird in Delphi ein + verwendet
Weitere Operatoren:
+ Addieren
- Subtrahieren
* Multiplizieren
/ Dividieren
. ist das was bei uns , ist (aus 2,2 wird 2.2)
= Vergleich
:= Zuweisung/Setzung eines wertes
Hat man 2 Texte (Strings) so kann man damit wohl nicht rechnen, sondern wenn man schreibt
Self.Caption:= 'Hallo '+'Welt';
so ist das genauso wie
Self.Caption:='Hallo Welt';
so läuft das auch mit Variablen und Konstanten
Const StringConst1: String='Hallo ';
begin
Self.Caption:=StringConst1+'Welt';
end;[Umwandlung]
Nun gibt es nur noch ein kleines Problem: Man rechnet 2 Variablen vom typ Integer zusammen, was raus kommt ist natürlich auch ein Integer. Nun will man das aber als text z.b. In einem Label Rausgeben, dann steht man da: Wie mache ich aus Integer jetzt String.
Die Antwort ist Denkbar einfach: Delphi bietet dafür einen Befehle (Noch aus Pascal zeit):
Die 4 Wichtigen befehle lauten:
1.
IntToStr(IntegerVariable) Das macht aus einem Integer einen String z.b.
Self.Caption:=IntToStr(4);
2.
StrToInt: Damit kann man aus einem String (z.b. einem Edit, einem feld in das der User was eintragen kann) einen Integer wert machen:
IntVar:=StrToInt(Edit1.Text);
3. FloatToStr: Hiermit kann aus einer Kommazahl ein string gemacht werden. Delphi macht für DT PCs automatisch aus dem . ein , also aus 2.2 2,2
Self.Caption:=FloatToStr(RealVariable);
3. StrToFloat: Somit kann man einen string in eine real/Single/extended variable lesen:
RealVariable:=StrToFloat(Edit1.Text);Hier mal ein paar kleine BSP Projekte:
Download Zip
Hinweis: mit // werden kommentare eingeleitet, da kann man schreiben was man will, das ist für Delphi unsichtbar.
Für Kommentare mit bestimmten ende oder welche die über mehere zeilen gehen sollen verwendet man {}
somit wird alles ab einem { ignoriert bis das erste } kommt
Noch ein Kleiner Zusatz:
Die Namensgebung sollte auf jeden fall beachtet werden. Variablen namen sollten volgende kriterien erfüllen: Etwas über die Funktion aussagen, in Englisch sein, kurz sein.
Somit kann damit jeder was anfangen.
Da ich die Tutorials zu erst unter Internetfreaks WBB schreibe kann es sein das manche sachen hier von den tags her unstimmig sind. Für die Beste Version müsst ihr wohl oder übel im WBB Forum nachsehen:
https://www.coding-cluster.net/74-tutorials/3…-mit-delph.html