[Delphi] Tutorial für Einsteiger

[HardCore.1337]

Willkommen zu meinem wohl längsten Tutorial, das ich je schreiben werde.
Hier geht es darum, euch die Sprache Delphi näher zu bringen.
Delphi wird oft nicht so gerne gesehen obwohl die sehr einfach zu erlernen ist und durch aus mit C++ mithalten kann. Was hindert uns also daran sich die (Hoch)Sprache näher zu betrachten und seine Vorzüge zu erkennen.

Inhalt

- Delphi? Was ist das?
- Warum gerade Delphi?
- Vorteile / Nachteile
- Grundlagen
- Ein erstes Projekt
- Windows API. Was ist das? Teil 2
- Weiterführendes: OOP, Assembler in Delphi… Teil 2

Delphi? Was ist das?

Delphi ist eine Hochsprache, mithilfe man ganz einfach Programme erstellen kann.
Delphi basiert auf Pascal, das 1972 gegründet wurde. Pascal war eine mit der ersten Sprachen, die strukturierte Programmierung erlaubte und diese auch permanent durchsetzte.
Delphi im heutigen Sinne wurde 2003 von Borland gegründet. Die Sprache ist dabei (fast) die gleiche geblieben, allerdings gibt es keine Konsolenanwendungen mehr, sondern man kann die GUI über einen Designer gestalten. Aktuell sind wir bei der Version 2010. Die beherrscht auch die Programmierung für Linux und Delphi for .NET.

Warum gerade Delphi?

Delphi ist eine sehr leicht zu erlernende Programmiersprache mit hohem Funktionsumfang.
Sie zeichnet sich durch eine einfache OOP (Objekt orientierte Programmierung) aus.

Weitere Vorteile sind folgende:

- Leicht zu erlernender Syntax
- Gute bedienbare DIE
- Sehr guter Debugger

Im folgenden Tutorial zeige ich euch, wie leicht es eigentlich sein kann, eine eigene Win32 Anwendung zu erzeugen.

Vorteile /Nachteile

Natürlich hat Delphi auch so seine Nachteile. Wie jede Programmiersprache halt.
Um nur einige zu nennen.

Nachteile
Keine Hardware nahe Programmierung. Das heißt, es können nur sehr schwer Treiber erstellt werden.
Geringe Verbreitung (es gibt aber trotzdem genug Tutorials im Internet)
Im Beruf nicht so gefragt
Entwicklungsumgebung recht teuer

Aber warum sollte man es da lernen? Naja, stimmt schon. Aber es gibt auch sehr viele Vorteile, die meiens Erachtens die Nachteile in den Schatten stellen.

Vorteile
- Leicht zu erlernte Sprache
- Dll Dateien können erzeugt werden. Ebenso können einfach neue Komponenten erstellt werden.
- Große Community
- GUI kann aus einem Baukasten System zusammen gebaut werden. Das heißt, es müssen keine API Befehle gecallt werden.
- Die IDE ist übersichtlich.

An unsere C++ Coder. Delphi interessiert Groß/Kleinschreibung nicht!

Ich rede die ganze Zeit von einer gewissen IDE. Doch was genau ist das?
IDE heißt ausgesprochen „Integrated Development Environment“ und bedeutet so viel wie „Integrierte Entwicklungsumgebung“.


Wer weiterhin im Netz nach Tutorials sucht, wird eine große Auswahl finden.
Einige Seiten seien hier genannt.

-
-
-

Wer sucht der findet immer. Gerade bei Delphi gibt’s sehr viele Themen zu fast jedem Problem.

Grundlagen

Ok, genug der Theorie. Fangen wir mit Programmieren an.
Doch halt. Wie anfangen? Einfach so?

Das wäre sehr falsch, da gerade Einsteiger gerade dann die Motivation verlieren, wenn sie sich ihr Ziele nicht erfüllen können.

Dazu brauchen wir aber erst mal Delphi. Da Delphi sehr teuer ist habe ich hier eine kostenlos alternative rausgesucht.


Beginnen wir als mit den Grundlagen.


Variablen:

Variablen sind Platzhalter, wie sind evtl. Schon aus der Mathematik bekannt sind. Wer nicht weiß, was Variablen genau machen, sollte hier aufhören zu lesen und sich ein zumindest grobes Mathematik Verständnis aneignen

Variablen werden mit folgendem Wort deklariert.

Var

Var steht für „Variable“. Nach dem Var kommt der Name, wie die Variable heißen soll. Dieser Name muss mit einem Buchstaben beginnen. Das bedeutet, keine Zahlen oder Sonderzeichen.

Var Test

Danach kommt der Typ. Der Typ bestimmt, was für ein Format die Variable haben soll.
Es gibt viele Variabeltypen. Die wichtigsten sind hier aufgelistet.

Typ	Bedeutung
Integer	Speichert ganze Zahlen
String	Speichert eine Zeichenkette (bis 2Mrd. Zeichen)
Boolean	Speichert einen Status (True oder False)
Char	Speichert ein einzelnes zeichen
Double	Speichert eine Kommazahl

Weitere Typen werde ich euch später erklären. Aber erstmal ist dies das wichtigste.

Wollen wir z.B. einen String (Zeichenkette wie z.B. "Hallo" speichern benötigen wir ein String).
Dies vereinbaren wir mit einem Doppelpunkt (:).
Das sehe nun wie folgt aus:

Var Test: String;

Wichtig: Jede Anweisung (außer Ausnahmen) wird mit einem Semikolon abgeschlossen!



Schleifen

Es gibt 3 Arten von Schleifen.
Alle haben Vor und Nachteile, aber im Grunde braucht man jede für eine andere Aufgabe und da sind sie unerlässlich.

While Schleife:

Die While Schleife hat folgenden Sytntax:

While Ausdruck = true/false do
         begin
            //Anweisung
         end;

Puhh, soviel neues.
Ok, ins Deutsche übersetzt würde das heißen.

SOLANGE Ausdruck (nicht) erfüllt TUE
         begin
            Deine Anweisungen ausführen
         end;

Z.B. könnte man es so anwenden.

While i < 500 do
         begin
            i := i + 1;
         end;

Für diese Anweisung wäre die nächste Schleife auf jeden Fall praktischer, aber die zeigt was sie macht. Ins Deutsche übersetzt.

SOLANGE i unter 500 tue
         begin
            i um 1 erhöhen (i := i + 1);
         end;

For-to-do Schleife

Diese Art von Schleife ist dafür da, wenn man weiß wie oft eine Aktion wiederholt werden soll. Wenn z.B. 100 mal Ein Textfeld ausgegeben werden soll, muss zuerst eine Variable von Typ Integer deklariert werden.

Var i: integer

Danach kann sofort die Schleife beginnen.

For i := 1 to 100 do
        begin
           ShowMessage('Hallo');
        end;

Was passiert hier? am anfang wird der Variable i der Wert 1 zugewiesen.
Dies geschieht mit
i := 1

Der Doppelpunkt mit dem ist gleich dahinter ist ein Zuweisung Operator.
Mit ihm werden Werte in eine Variable eingefügt.

Nachdem i = 1 ist, wird einmal ein Fenster angezeigt. Dieses zeigt nun "Hallo" an. Nun wird i um 1 erhöht. Dies sieht man nicht, aber es passiert. Im Grunde machen wir das gleiche wie oben bei der While Schleife.

Repeat-Until Schleife

Dies Schleife ähnelt der While-do Schleife.
Nur das hier erst der Code ausgeführt wird und danach die Abbruchs Bedingung.

Der Syntax sieht hier wie folgt aus.

Repeat
         Anweisung
         Until i = 500;

Also so etwa:

Repeat
         i := i + 1;
         Until i = 500;

Diese Schleife nutze ich relativ wenig, da sie mir einfach nicht gefällt


Bedingungen

Ein Programm darf nicht linear Ablaufen, sondern muss auf Ereignisse reagieren. Dafür gibt es Bedingungen.

if-then-else

Die Wohl Berühmteste und auch einfachste

if Variable = true then Anweisung1 else Anweisung2

Um dies zu verstehen, erstellen wir eine neue Variable vom typ Boolean.

Var Running: Boolean;

Dieser weisen wir gleich den Wert "True" zu.

 Var Running: Boolean = True;

Erstellt nun folgenden Code.

if Running = true then 
           ShowMessage('Boolean hat den Wert "True")
         else
           ShowMessage('Boolean hat den Wert "False");

Ok, was machen wir hier. Wir überprüfen ob die Variable "Running" den Wert true hat. Wenn ja, erzeugen wir eine MessageBox mit dem Inhalt ("Boolean hat den Wert true") ansonsten ("Boolean hat den Wert false").

Nochmal ins Deutsche:

WENN Runnig = true(wahr) DANN 
           SHowMessage ('Boolean hat den Wert True')
         SONSt
           ShowMessage('Boolean hat den Wert false');

Ändert nun mal die Variable in False

Var Running: Boolean= false;

Startet das Programm mit F9 und seht was passiert.

So, das waren erst mal die Grundlagen. Ein paar wichtige Hinweise gibt es aber noch.

Weiter wichtige Dinge
Anweisungen werden mit einem ; abgeschlossen
Der Variable wird mit := ein Wert zugewiesen.
Groß und Kleinschreibung spielt keine Rolle

Ein erstes Projekt

Wir haben nun die minimalen Grundlagen die wir brauchen um ein ganz einfaches Programm zu erstellen.

Idee:
Was wollen wir programmieren. Zu aller erst etwas einfaches, das die gewonnen Fertigkeiten ausschöpft.

Wir werden ein Rechner bauen, der ausrechnet, wie viel Geld wir bei x Zinsen und x Jahren Laufzeit haben.

Endlich gehts los
Startet nun als erstes Delphi. Darin müsst ihr ein neues Formular eröffnen.




Nun seht ihr eure IDE.



Erklärung

1: Eure Formular. Dieses wird eure GUI mit der ihr arbeitet
2: Objektinspektor. Hier legt ihr Eigenschaften, Ereignisse... fest
3: Komponentenliste. Hier könnt ihr euer Formular mit Komponenten
bestücken. Diese zieht ihr einfach per Drag and Drop auf das
Formular.
4: Menü. Hier legt ihr allgemeine Einstellungen fest
5: objekthierarchi: Eine Art Stammbaum eures Formulares

Bestücken des Formulars

Bestückt nun eurer Forumlar mit folgenden Komponenten.
3 Labels, 3 Edit Felder und Button. DIes Komponenten befinden sich alle auf der "Standart" Palette.

Zieht sie auf euer Formular und bestückt sie so wie ich.



Im Objektinspektor könnt ihr nun die Eigenschaften ändern. Beschriftet die Komponenten um. Klickt auf die Labels und sucht "Caption". Dort tragt ihr den gewünschten Namen ein. Beim Button genauso. Das Editfeld wird im Abschnitt "Text" beeinflusst.

Ok, nun Doppelklickt auf den Button. Hier seht ihr nun den Quelltexteditor.
Dieser Bedarf wohl einer Erklärung, obwohl ihr vieles noch gar nicht wissen müsst.

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls; //eingebundene Datein (in C++ include gennant). Sie stellen zusätzliche Funktionen bereit

type
  TForm1 = class(TForm)
    Label1: TLabel;
    Label2: TLabel;
    Label3: TLabel;
    Button1: TButton;
    Edit1: TEdit;
    Edit2: TEdit;
    Edit3: TEdit;
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;  //Öffentliche Varaibeln -> siehe Grundlagen

implementation

{$R *.dfm}

//Unterhalb von implementation kommt unser Code

end.

Doppelklickt ihr nun auf den Button erscheint folgender Quellbereich:



Dort gebt ihr nun folgenden Code ein.

Kapital := StrToFLoat(Edit1.Text); //wandelt den String aus Edit1 in  eine Gleitkommazahl
Prozent := StrToFLoat(Edit2.text);
Laufzeit := StrToInt(Edit3.text);

for i := 1 to Laufzeit do //Die Schleife wird so oft durch geführt wie in edit3 angeben
begin
  Zinsen := Kapital * Prozent/100; //eigentliche Rechnung
  Kapital := Kapital + Zinsen;
end;
Edit1.Text := FloatToStr(Kapital); //Das Kapital nach x Jahren wird dargestellt

Fügt den Code nun ein.
Startet ihr das Programm nun(F9) erhaltet ihr einen Fehler. Der Grund:
weder Kapital oder Laufzeit noch Zinsen und i sind als Variablen vereinbart.

Geht nun in den Var Abschnitt und fügt es hinzu. Als Typ nehmen wir einen Double, da wir mit Komma zahlen arbeiten

Außerdem ist Laufzeit vom typ integer und muss mit i in der Button1 Procedure vereinbart wird,




Startet das Programm mit der F9 Taste und seht was ihr geschaffen habt.

Abschluss

Ich hoffe ihr habt etwas verstanden. Ich werde mal mein Tutorial fortsetzen und euch dann in die Geheimnisse der Windows API und der OOP entführen. Wenn ihr nun noch ein wenig mit Delphi spielt, werdet ihr merken, was man damit alles machen kann.

[HardCore.1337]

Grundlagen weiterführend

In der Weiterführung gehts es um folgende Schwerpunkt Themen.

• Array´s
• Operatoren
• Funktionen und Prozeduren

Arrays

Viele haben den Begriff sicher schon einmal gehört, wissen damit aber nichts anzufangen. Nun das ist nicht schlimm, denn am Ende dieses Tutorials wird es eine Kleinigkeit sein, Arrays zu benutzen.

Array muss man sich wie ein Bücherregal vorstellen. In jedem Schubfach befindet sich ein Buch. Diese kann man nun ganz einfach raus nehmen und weiter bearbeiten.

Stellen wir uns das so vor.



Nun können wir ganz einfach die darin enthaltenen Daten aufrufen.

Außerdem haben Arrays einen weiteren Vorteil. Sie können ja mehrere Daten eines Datentyps aufnehmen und so für Ordnung im Quelltext schaffen.

Am besten zu demonstrieren geht das ein einem Codebeispiel.
Stellen wir uns vor wir wollen 10 Zufallszahlen erzeugen und
jeweils in einer eigene Variable speichern. Das ginge so Problemlos

var z1, z2, z3, z4, z5, z6, z7, z8, z9, z10: Integer;

Aber wenn man das mit 1000 Zufallszahlen macht, wird man keine Lust haben, 1000 Variablen zu erstellen.

Also speichern wir dies in einem Array ab. Und das geht auch ganz einfach.

var z: Array[0..10] of Integer;

Erklärung
also zuerst sagen wir wie die Variable heißen soll. In diesem Fall z.
Dann deklarieren wir mit Wort Array die Anzahl der Elemente. Diese werden in Klammern [] geschrieben und mit 2 Punkten (..) verbunden

Array[0..100]

Erzeugt einen Array mit 100 Elemten.

zum Schluss wird noch angegeben, welchen Typ man benutzen soll. Dieser wird mit dem Wort of gekennzeichnet.

Kleines Demo Programm

Zur Demo füllen wir alle 100 Variablen mit Zufallszahlen.
Dafür muss die Größe von dem Array bekannt sein, die man mit High herausbekommt. Außerdem brauchen wir eine Zählervariable. Ich nenne sie i.

var
  Form1: TForm1;
  z: Array[0..100] of Integer;
  i: integer;

Erstellen wir nun eine For Schleife.

For i := 0 to [B]High(z)[/B] - 1 do
begin
  [B]z[i][/B] := random(2000);
end;

Ein Element wird immer mit der Nummer hinter dem Variablennamen angegeben. Will man z.B. das 5 Element aus der Variable 5 öffnen schreibt man z[5]
5 Gibt nun an, das das 5 Element frei gegeben wird.

Als Abschluss führen wir das Programm noch zuende. Erstellt dazu eine ListBox(Reiter: Standart).

Doppelklickt nun auf das Formular und ergänzt den Code wir folgt.

For i := 0 to high(z) - 1 do
  begin
    ListBox1.Items.Add(IntToStr(z[i]));
  end;

Dies sieht nun so aus.



Startet das Programm und seht.
Als erstes haben wir die Zahl in einen String umgewandelt (IntToStr(z[i])) und anschließend in der ListBox dargestellt.

Dies geht natürlich auch mit Strings, worauf ich aber auf andere ausführlichere Tutorials hinweise.

Operatoren

Unter Operatoren versteht man die gängigen Methoden, Sachen zu addieren, multiplizieren...
Dies funktioniert wie überall anders auch. Deshalb soll dies hier nicht zu ausführlich werden.

Beispiel Programm
Wir nehmen wieder einen kleinen Rechner.

var Zahl1, Ergebnis, Zahl2: Double;

Nun wollen wir ganz einfach Zahl1 mit Zahl2 dividieren.

Ergebnis := Zahl1 / Zahl2

Weitere Operatoren

Operator	Bemerkung
+	Addiert zwei Zahlen oder Strings miteinander
-	Subtrahiert zwei Zahlen oder Strings miteinander
*	Multipliziert zwei Zahlen oder Strings miteinander
/	Dividiert zwei Zahlen oder Strings miteinander
Div	Dividiert zweit Integer Zahlen. Das Ergebnis wird gerundet
mod	Gibt den Rert einer Division wieder

Außerdem gibt es auch noch logische Operatoren.

Operator	Bemerkung
and	Prüft ob Bedienung a und b wahr sind
or	Prüft ob Bediengung a oder b wahr sind
not	negation
xor	entweder-oder

Ein kleines Beispiel für logische Operatoren

if (a [B]and [/B]b = 10) [B]or [/B](c [B]and [/B]d = 100) then

Hier wird wie folgt vorgegangen:

1. Prüft ob a und b gleich 10 sind
2. wenn das nicht der Fall ist, wird geprüft ob
3. c und d = 100 ergeben

Das soll es zu den Operatoren gewesen sein. Dieses Thema ist dabei relativ einfach, weil es nur mit logischem Denken zusammen hängt.

Funktionen und Prozeduren

Funktionen und Prozeduren spielen eine entschiedene Rolle eines jeden Programmierers. Sie nehmen und Tipparbeit ab und sorgen für übersicht.

Der Unterschied von Funktionen und Prozeduren liegt darin, das Funktionen einen Rückgabelwert haben, Prozeduren nicht.

Stellen wir uns vor, wir arbeiten an einem Programm, das 2 Button hat. Es wird pro Button der gleiche Algorithmus verwendet, nur die Zahlen sind anders.

var
  Form1: TForm1;
  x, y,z: double;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
begin
  x := 10;
  y := 20;
  z := Sqrt(x+y);
  z := cos(z);
  ShowMessage(FloatToStr(z));
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  x := 50;
  y := 40;
  z := Sqrt(x+y);
  z := cos(z);
  ShowMessage(FloatToStr(z));
end;

end.

Zweimal die gleiche Rechnung (die in der Tat sinnlos ist), nur das x und y andere Werte haben.
Wie umgehen wir diese Tipparbeit und der damit resultierenden Unordnung.
Wir erstellen eine Funktion, wo wir die Rechnung einmal aufstellen und dann x und y als Parameter übergeben.

Aufbau einer Funtktion

[B]function Funktionsname(Variable: Variabletyp): RückgabeTyp;[/B]

Unsere Funktion nennen wir ganz einfach mal Rechnung.
Als Parameter erwarten wir die Variablen x und y, da wir diese ja mit unterschiedlichen Werten füllen wollen.

[B]function Rechnen (x, y: Double): Double;[/B]

Jetzt erstellen wir unseren Code.

function Rechnen(x, y: double): Double;
begin
  z := Sqrt(x+y);
  z := cos(z);
  result := z;
end;

Result ist eine Standartvariable, die den Rückgabelwert beinhaltet.

Doppelklick nun auf den Button1 und ruft die Funktion auf.

ShowMessage(FloatToStr(Rechnen(10,20)));

.
Erst wird darin die Funktion Rechnen aufgerufen und mit den Werte 10 und 20 gefüllt. Der Resultwert wird dann in einen String umgewandelt und in einer MessageBox angezeigt.

Viele werden sich jetzt vielleicht fragen wo die Funktion hinkommt. Ganz einfach unter das Wort implementation .

implementation

{$R *.dfm}

function Rechnen(x, y: double): Double;[B]
...[/B]

Prozeduren funktionieren geanu so, nur das sie keinen Rückgabelwert haben.

Ihr Aufbau unterscheidet sich nicht wirklich, nur das das Wort Funktion wegkommt und stattdessen durch Procedure ersetzt wird.

Eine einfach Prozedur:

implementation

{$R *.dfm}

Procedure Test(Inhalt: String);
begin
  ShowMessage(Inhalt);
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  Test('Hallo, ich komme aus der Prozedure!');
end;

end.

Und wenn man auf den Button klickt.



So, das wars mal wieder
Im nächsten Tutorial werde ich mich mehr um die Erfahrenen kümmern

[HardCore.1337]

So, widmen wir uns dem 2. Teil des Tutorials.
Das 1. Tutorial war noch sehr auf Anfänger hingerichtet.
Hier werde ich ein paar komplexere Dinge erklären, weswegen es vlt. nicht für Anfänger geeignet wäre, die nicht nicht oder nur schwer logisch denken können.

Inhalt Teil 2

- Windows API. Was ist das?
- Fehlerabfragen...

Windows API. Was ist das?

Zuerst müssen wir uns im klaren sein was API eigentlich bedeutet.
Es bedeutet ausgesprochen Application Programming Interface und bedeutet soviel wie Anwednugs Programmierschnittstelle.
Diese API wurde von Microsoft entwickelt (Windows API) und stellt verschieden Funktionen bereit mit denen wir arbeiten können.
Dazu gehören hauptsächlich System spezifische Funktionen wie das ändern von Speicheradressen und so weiter.

Eine komplette Auflistung will ich hier nicht geben, da es den Platz sprengen würde. Allerdings gibt es eine sehr schöne Internet Seite, wo alle aufgelistet sind.



Wie bindet man diese aber jetzt in Delphi ein?
Ganz einfach. Einfach oben bei Uses die Datei Windows eintragen




Nun können wir alle Befehle nutzen, die uns diese sehr schöne API bietet.
Da wir hier in einem Gamehacking Forum sind, werden wir eine kleines Programm schreiben, das uns eine Speicheradresse ändert.

Zum suchen der Adresse verweise ich hier auf andere ebenfalls sehr gute Tutorials.

Öffnet nun Delphi und erstellt ein neues Projekt (-> Tutorial 1).
Nun doppelklickt auf euer Forumlar und gebt folgenden Code ein.

procedure TForm1.FormCreate(Sender: TObject);
var
  ThreadID: Integer;
  ProcessID: Integer;
  wnd: HWnd;
  write: cardinal;
  v1: Cardinal;
  buf: PChar;
  WindowHandle: Integer;
begin
  v1 := $1000;
  wnd := FindWindow(nil, 'Spider Solitär');
  if wnd <> 0 then
  begin
    ThreadID := GetWindowThreadProcessID(wnd, @ProcessID);
    WindowHandle := OpenProcess(PROCESS_ALL_ACCESS, False, ProcessID);
      buf^ := Chr(v1);
      WriteProcessMemory(WindowHandle, ptr($01263AA8), buf, 4, write);
    CloseHandle(WindowHandle);
    end
    else
      ShowMessage ('Fehler!');
  end;

Ok, was machen wir hier. als erste deklarieren wir einige Variablen.
Und dafür brauchen wir einige.

ThreadID: Integer;
  ProcessID: Integer;
  wnd: HWnd;  
  write: cardinal;
  v1: Cardinal; 
  buf: PChar;  
  WindowHandle: Integer;

Erklärung

Variable	Bedeutung
ProcessID	jeder Prozess hat seine eigene ID. Diese wird hier gespeichert
ThreadID	Die ID von dem Main Thread der Anwendung
wnd	Zur überprüfung ob der Prozess exestiert
write	Bestimmt, mit wie viel Byte geschrieben werden soll
v1	Der Wert, den wir in den Speicher schreiben
buf	Dient hier als Zeiger Variable und nimmt später v1 auf
WindowHandle	Das eigentliche Handle

Wer nicht mehr folgen kann, sollte sich evt. doch erst mal ein paar weniger schwierige Tutorials anschauen. Für alle die es verstehen, gehts jetzt hier weiter.

Als nächstes wollen wir bestimmen, welcher Wert später in den Speicher rein soll.

v1 := 10000;

Also schreiben wir jetzt den Wert 10000 in den Speicher. Aber so schnell geht es noch nicht. Wir brauchen erst mal die Genehmigung vom Prozess.
Außerdem wollen wir noch Prüfen ob der Prozess existiert.

wnd := FIndWindow(nil, 'Spider Solitär'); //Sucht den Prozess Spider Solitär
if wnd = 0 then
  ShowMessage ('Bitte erst Spider Solitär starten!')
else
begin
  //hier gehts jetzt weiter

Holen wir uns nun die rechte vom Prozess und öffnen das Handle.

ThreadID := GetWindowThreadProcessID(wnd, @ProcessID);
    WindowHandle := OpenProcess(PROCESS_ALL_ACCESS, False, ProcessID);

Die Befehle sollten selbsterklärend sein, wenn man ein wenig Ahnung von Englisch hat.

Parameter

Befehl	Paramter
GetWindowThreadProcessID	Handle der Anwendung, ProzessID
OpenProcess	Flag, False, ProcessID

Für nähere Beschreibung verweise ich auf MSDN




Nun weisen wir der Zeiger variable buf unseren zu schreibenden Wert zu.

buf^ :=Chr(v1);

Das Dach (^) zeigt hier, das es sich um einen Zeiger handelt.

Jetzt wo wir alles haben, können wir in den Prozess schreiben.
Der Syntax hierfür lautet:

WriteProcessMemory[Process, Adresse, Buffer, Size, Nummer der zu schreibenden Bytes

Erklärung

Parameter	Erklärung
Process	In diesem Fall WindowHandle. Diesen haben wir mir OpenProcess geholt
Adresse	Die Speicheradresse in Hex schreibweise. Wir mit einem $ eingeleitet
Buffer	hier kommt unser buf hinein
size	Den Wert den wir in den Speicher schreiben wollen.
Nummer	Die byteanzahl. Bei uns hier 4Byte

Damit wird nun der Speicher beschrieben.

WriteProcessMemory(WindowHandle, ptr($01263AA8), buf, 4, write);

am Ende wir das Handle wieder geschlossen und zwar mit CloseHandle

CloseHandle(WindowHandle);

startet nun das Programm und seht.



Das war nun unser kurzer Ausflug in die WinAPI.

Fehlerbehandlung

Es gibt in Delphi verschiedene Wege, eine Fehler zu behandeln.
Ich werde euch nun erklären, wie ihr mittels try...except und try...finally
sicher einen Fehler abfangen könnt.

Wie geht das also?
Auf der Abbildung sieht man eigentlich das wichtigste.


Das heißt, wenn ein fehler in einem Programmblock auftreten sollte, wird die Bearbeitung des Blockes beendet und ein Notfallblock wird aufgerufen.
Sollte nix passieren, wird das Programm ganz normal fortgesetzt.

Als kleines Beispielprogramm entwickeln wir uns einen Rechner.
Startet also ein neues Projekt und erstellt euch eine Form wie meine hier



Doppelklickt nun auf den Button und fügt folgenden Code ein.

procedure TForm1.Button1Click(Sender: TObject);
var Ergebnis, x, y: double;
begin
    x := StrToFloat(Edit1.Text); //wandlet Edit1 in eine Gleitkommazahl um
    y := StrToFloat(Edit2.Text); // -""-
    Ergebnis := x/y;
    ShowMessage(FloatToStr(Ergebnis));
end;

Startet das Programm und tragt irgendwo eine 0 ein.
Klickt auf Berechnen und ihr werdet mit einer Messsage überrascht die etwa so aussieht



Sieht ziemlich unschön aus.
Das können wir auf jeden Fall besser.
Was wir jetzt machen, ist unseren Code um ein Try...except Paar zu bereichern.

normales Programm
[COLOR=Red][B]try[/B][/COLOR]
  [COLOR=Black]hier wird ein fehler erwartet[/COLOR]
[B][COLOR=Red]except
  [/COLOR][/B][COLOR=Red][COLOR=Black]Wenn der Fehler auftritt wird der Code hier ausgeführt
[/COLOR][/COLOR]

Ok, programmieren wir los
ändert den Code nun wie folgt.

procedure TForm1.Button1Click(Sender: TObject);
var Ergebnis, x, y: double;
begin
  [B][COLOR=Red]try[/COLOR][/B]
    x := StrToFloat(Edit1.Text); //wandlet Edit1 in eine Gleitkommazahl um
    y := StrToFloat(Edit2.Text); // -""-
    Ergebnis := x/y;
    ShowMessage(FloatToStr(Ergebnis));
[B] [COLOR=Red] except[/COLOR][/B]
    ShowMessage ('Also irgend etwas stimmt hier nicht :(');
end;
end;

Startet das Programm und gebt wieder irgendwo 0 ein.
Jetzt bekommt ihr so ein Fenster zu sehen.



Das sieht doch schon mal besser aus.
Ihr könnt auch mehrere Befehle hinter das except machen, bedenkt aber, das diese in einen begin...end Block müssen.


Try---finally

Der Try...finally Block ist eigentlich das selbe, nur das die Anweisung hinter Finally ausgeführt werden muss, egal ob ein Fehler vorhanden ist oder nicht.
Dies ist z.B. nützlich, wenn man eine Datei freigeben muss (z.B. eine Textdatei oder ein Handle). Dies wird selbst nach einem Fehler ausgeführt und sorgt für einen reibungslosen Ablauf des restlichen Codes.

Bsp. Code

procedure TForm1.Button1Click(Sender: TObject);
var Ergebnis, x, y: double;
begin
  [COLOR=Red][B]try[/B][/COLOR]
    x := StrToFloat(Edit1.Text); //wandlet Edit1 in eine Gleitkommazahl um
    y := StrToFloat(Edit2.Text); // -""-
    Ergebnis := x/y;
    ShowMessage(FloatToStr(Ergebnis));
  [B][COLOR=Red]finally[/COLOR][/B]
    ShowMessage ('Also irgend etwas stimmt hier nicht :(');

end;
end;

Startet das Programm und ihr werdet sehen, die Meldung wird jetzt immer kommen. Arbeitet ihr z.B. mit ini´s und gebt hinter finally den Befehl ini.free ein, wird dieser immer ausgeführt. Und genau das ist auch der Vorteil daran.

So, das war Teil 2 meines Tutorials. Im nächsten Teil werden wir uns verstärkt mit der OOP beschäftigen

[epiTR]

Huhu,
danke für die Mühe und habe jetzt schonmal die erste Frage und zwar:
Ich habe mir Freepascal gedownloadet und du zeigst ja wie das erste Projekt geht. Das Gui sieht gan anderst aus und ich denke mir ist auch ein anderes Programm!

[HardCore.1337]

Das liegt daran, das das Programm halt kostenlos und mein verwendetes was kostet.
Bei dir liegen die komponentenpalette oben

[Nosferatu.]

Repeat
         i := i + 1;
         Until i = 500;

Diese Schleife nutze ich relativ wenig, da sie mir einfach nicht gefällt

General Desert ob dir die Schleife gefällt oder nicht verhindert aber nicht den einsatz.

In vielen Situationen zb bei einer konsolenanwendung ist es sogar Notwendig diese "schleife" einzusetzen, da diese konsole ansonsten spätestents nach drücken von enter zu ist 100% . Und das kann man mit for I schleife net machn (bzw net wirklich).

Es gibt soviele gründe warum diese einfach dazu gehört und du wirst es noch rausbekommen ^^.

...:='Searching Notepad ..';

repeat
 hwnd:=FindWindow('notepad','');
until hwnd <> 0;

Code abschnitt solange ausführen bis "Notepad" gefunden ist, und das kann 365 tage sein. 
Eine Fori schleife hört irgendwann auf zu suchen, oder du bekommst einen Hessligen Excption Fehler,
 da Integer max  -2147483648 bis 2147483647  haben kann. 

Zitat: Schleifenvariablen dürfen grundsätzlich innerhalb der Schleife nicht verändert werden.

Oder du bekommst ihn nimmer aus @Endlos schleife^^

[COLOR="Red"]try[/COLOR]
  hier wird ein fehler erwartet
[COLOR="Red"]except[/COLOR]
  error
[COLOR="Red"][U]end;[/U][/COLOR]

nicht normal sondern wenn erfolgreich.

[COLOR="Red"]try[/COLOR]
  hier wird ein fehler erwartet
[COLOR="Red"]finally[/COLOR]
  erfolgreich.
[COLOR="Red"][U]end;[/U][/COLOR]

PS: Die Try sache ist auch da um (Hessliche) errors abzufangen / 
um schlimmere errors zu verhindern, 
indem Man einfach mit [COLOR="Red"]Exit[/COLOR] die Procedure / Function verlässt, oder sie zb zu beheben in Except abschnitt.

[.nAno]

nice work (bin überrascht wie schnell du das geschrieben hattes )
Thx

Und sobald du den Platzhalter gefüllt hast aufjedenfall:
vote4sticky

endlich kommt auch Delphi zum Wissensschatz von e*pvp hinzu^^

[HardCore.1337]

So, das war´s nun
Ich würde mich über Feedback freuen, da es doch eine ganz schön lange Arbeit war

[.nAno]

ganz klar: Sticky

[Nosferatu.]

gut gestaltet
sehr übersichtlich
gut erklärt

vote4sticky

[Cholik]

Vielleicht könntest du das Bild nochmal neu machen.

Beispielsweise als Programmablaufplan oder Nassi-Shneiderman-Diagramm.

Beim Programmablaufplan hätte es nen logischeres Aussehen und wär wohl am einfachsten zu verstehen für Anfänger. Microsoft Visio hält das u.a. als Schablonen schon bereit.

[HardCore.1337]

Ok, vielen Dank für die Anregung.
Ich werde mich sofort davor setzen

€: Ok, Bild wurde verbessert

[DeLuxeStyLez]

Sehr gute Arbeit.
Delphi ist nix für mich, da bleib ich lieber bei VB.

[beefm4ker]

also ich hab mir Delphi 2010 besorgt und naja hab dann auch den Anfang mal gemacht und dann stieß ich auf ein Problem mir schreibt er immer dass wenn ich F9 drücke dass da 2 Datentypen nciht zueinder passen würden Integer und extenden bei der Variable Laufzeit edit3 Feld iwas... (mom muss nochma genau nachgucken )

[HardCore.1337]

Wenn du einen Integer hast muss du das so schreiben.

Test := StrToInt(Edit3.Text); //wandelt den String(aus Edit3) in eine Ganzzahl um

und mit extended

Test := StrToFloat(Edit3.text); //das gleiche, nur hier kommt eine Kommazahl raus

Ansonsten mal den Quelltext posten