[Nils_13]

hi!

Delphi Anfänger-Tutorial
Dies ist ein nicht so langes Tutorial, wie es scheint. Es kommen viele Code-beispiele drinnen vor.

Ich erkläre oft im Code mit Delphi-Tags etwas (// oder {})

Grundvorraussetzungen: Delphi ist Installiert, falls nicht: CD einlegen, Installer starten, Delphi auswählen und installieren.


Inhaltsverzeichniss:
2: Typen
3: Komponenten
- MainMenu
- Label
- Button
- Edit
- Memo
- Dialoge
- OpenDialog
- SaveDialog
- ListBox
- ComboBox
- Panel
- GroupBox
- CheckBox/RadioButton
- RadioGroup
- PopupMenu

4: Ein kleiner Rechner


1: Typen
Es gibt in Delphi verschiedene Variablen, die einen vollkommen andern Sinn haben.
Integer : ganze Zahlen
Byte : natürliche Zahlen
Boolean : Boolischer Wert (True oder False)
Real : reele Zahlen
String : Zeichenkette
Binärdatei : File of Byte, File of Integer, File of Char, File of RecordTyp

Es gibt globale Variablen.

sie werden in var deklariert.
Str: String;
Str ist die Variable. Einer Variable wird immer ein Typ zugewiesen (in dem Fall String).

man kann auch in jede procedure var hinschreiben und dahinter/drunter die variablen schreiben


3: Standart Komponenten

- MainMenu | Hauptmenü
Das Hauptmenü (TMainMenu) dient dazu am oberen Fensterrand ein kleines Menü darzustellen, z.B. Datei | Bearbeiten | Ansicht | Hilfe
Wenn man auf Datei klickt, erscheint meistens ein 'Untermenü'. Z.B. Neu | Öffnen | ...

Starten sie Delphi.

Nun breitet sich Delphi vor ihnen aus.

In dem oberen Fenster gibt es eine Komponenten Palette (Standart | Zusätzlich | ...). Wählen sie Standart aus. Unter Standart erscheinen jetzt viele Komponenten. Fahren sie mit der Maus über eine Komponente und es erscheint ein Hinweis (Hint), welche Komponente es ist. Wählen sie 'MainMenu' mit einem Klick auf die komponente aus. Gehen sie nun mit der Maus zur Form (z.B. Form1). Klicken sie ebenfalls. Nun wurde eine Komponente auf der Form eingefügt. Um ein Menü zu erstellen, müssen sie erst Delphi sagen, welche Items angezeigt werden sollen, sonst wird das Menü nicht angezeigt. Entweder klicken sie doppelt auf die Komponente auf der Form, oder sie wählen den Objektsinspector aus und klicken (wenn sie das MainMenu auf der Form ausgewählt haben) auf Items. Hinter '(menü)' erscheinen jetzt drei Punkte. Klicken sie drauf und es erscheint ein weiteres Menü. Ein Menü besteht grundsätzlich aus MenuItems. Im Objectinsceptor sollte bei ihnen das Item '<Unbenannt' ausgewählt sein. Nachdem sie auf 'Caption' geklickt haben, erscheint dahinter ein textfeld (eigentlich edit). Tippen sie z.B. '&Datei' ein. Wenn man vor einem Buchstaben ein '&' schreibt, wird dieser unterstrichen. Klicken sie in dem MainMenu-Editor auf den vorherig eingegebenen Text. Nun erscheint ein SubMenuItem. Wenn sie drauf klicken, können sie wieder mit Caption einen Text eintippen.
Kehren sie nun zur Form zurück und klicken doppelt darauf (sie können auch im Objectinspector unter 'Ereignisse\OnCreate gehen').
Um den Text abzuändern, müssen sie folgenden Code verwenden:

markieren

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
begin
  MainMenu1.Items[0].Caption := '&Hier stand mal Datei!';
end;

[Nicht das sie es falsch verstehen: das Code/Editor Fenster erscheint und FormCreate ist bereits vorhanden, sie müssen also nur noch
  MainMenu1.Items[0].Caption := '&Hier stand mal Datei!'; einfügen]
Sie können auch auf ein MenuuItem oder SubMenuItem doppelt klicken und sie gelangen zu dem Code-Editor, dann können sie dort ihren Code eintragen, der aufgerufen werden soll, falls der Benutzer auf das MenuItem oder SubMenuItem klickt.
Beispiel:

markieren

Delphi-Quellcode:

procedure TForm1.Neu1Click(Sender: TObject);
begin
  MainMenu1.Items[0].Caption := '&Sie haben gerade auf ein SubMenuItem geklickt!';
end;

So sieht das Grundgerüst aus:

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

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

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

var
  Form1: TForm1;

implementation

{$R *.dfm}

end.

Und hier der bisherige vollständige Code:

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TForm1 = class(TForm)
    MainMenu1: TMainMenu;
    Datei1: TMenuItem;
    Neu1: TMenuItem;
    procedure FormCreate(Sender: TObject);
    procedure Neu1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  MainMenu1.Items[0].Caption := '&Hier stand mal Datei!';
end;

procedure TForm1.Neu1Click(Sender: TObject);
begin
  MainMenu1.Items[0].Caption := '&Sie haben gerade auf ein SubMenuItem geklickt!';
end;

end.

Items sind die MainMenu Items (deshalb ja auch MainMenu1.). Wenn sie ':=' eingeben erwartet delphi einen weiteren Befehl (Je nach dem was davor steht).
Es hat sich nicht viel verändert, außer das zwei proceduren hinzugekommen sind und, dass sich auf der Form und im type etwas verändert hat.

Es gibt auch noch funktionen (function), denen man den Wert zuweisen kann.
Mit constructors werden wir uns in diesem Tutorial noch nicht rumschlagen.



- Label
Ein Label ist dazu da, um dem Benutzer z.B. bei Fehlern die Fehlermeldung auf elegante Weise mitzuteilen. Oder um z.B. in einem Player den Status anzuzeigen (Play, Stop, Pause, ...)
Man kann aber dem Label genauso viel oder sogar mehr zuteilen als einem MainMenu.
Wir könnten den selben Code auch in einem OnClickEreigniss (haben wir eben bei dem SubMenuItem auch schon verwendet) aufrufen und dem Label noch einen anderen Text zuweisen. Falls die größe bei keiner Komponente oder Form angepasst werden soll, stellen sie einfach AutoSize auf False (False = fehlgeschlagen, True = in etwa in Ordnung). Dies geschieht wie in dem MainMenu mit der Cpation, bloß dass sie einfach auf den nach unten deutenden Pfeil klicken und auf 'False' klicken. Mit True schalten sie AutoSize wieder ein. Die Zeile in OnCreate können sie mit // am Anfang der Zeile ausklammern, sie können für mehrere Zeilen { ... } nehmen.

markieren

Delphi-Quellcode:

procedure TForm1.Label1Click(Sender: TObject);
begin
  MainMenu1.Items[0].Caption := '&Hier stand mal Datei!';
  Label1.Caption := 'MainMenu.Items[0].Caption wurde abgeändert!';
end;

Fügen sie die erwähnte Komponente immer ein, dann muss ich es nicht immer sagen.
Nun wird wieder der Text des MainMenus abgeändert und der Label zeigt nun 'MainMenu.Items[0].Caption wurde abgeändert!' an.



- Button
Ein Button ist eine Schaltfläche. Wenn man auf einen Button klickt oder Enter/Return drückt, wird immer etwas neues ausgeführt.



- Edit
Ein Edit ist ein einzeiliges Textfeld. Wir können dem Edit Enter zuweisen.

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
begin
Form1.Color := clRed;
end;

procedure TForm1.Edit1KeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin
  if Key= VK_RETURN then
    Button1Click(Sender);
end;

Wenn sie Form1. eintippen erscheint die Programmierhilfe. Mit 'Form1.Color :='
können sie die passende Farbe bestimmen.

if ... then = wenn ... dann
VK_RETURN = Überprüfung, ob enter gedrückt wurde (ohne if, then geht das nicht)

Es gibt Parameter, wenn man eine procedure aus einer anderen procedure ausführen will, muss man den Parameter angeben, damit Delphi weiß, was es tun muss. Bei so Sachen wie OnClick ist es immer 'Sender'. Sie können sich die procedure anschauen und den Parameter bestimmen. Eine Zeile wird immer mit einem ';' beendet.

Egal was sie in das Edit eintippen und Enter drücken, es kommt immer das selbe raus.
Im folgenden Beispiel wird gezeigt, wie man per Button eingabe und Enter drücken zum selben Ergebnis kommt, bloß das nicht immer das Selbe raus kommt.

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.Edit1KeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin
{  if Key= VK_RETURN then
    Button1Click(Sender);  }
  if Key= VK_RETURN then
  begin
    if Edit1.Text = 'button' then Button1Click(Sender);
    Edit1.Clear;
  end;
end;

In den Klammern steht der alte Code. Auf ein begin folt immer ein end;. Sie können nur if ... then eintippen, aber nicht ein einzelnes Wort.
'if Edit1.Text = 'button' then Button1Click(Sender);' = Wenn sie button eintippen, dann ... .
'Edit1.Clear' = Text löschen.



- Memo
Ein Memo ist ein (mehrzeiliges) Textfeld.

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
begin
Memo1.Lines.Add (Edit2.Text);
end;

procedure TForm1.Edit2KeyDown(Sender: TObject; var Key: Word;
  Shift: TShiftState);
begin
  if Key= VK_RETURN then
  begin
    // text des zweiten edits in das Memo schreiben
    // erste Methode
    Memo1.Lines.Add (Edit2.Text);
    // zweite Methode
    Button2Click(Sender);
    
    // text löschen
    Edit2.Clear;
  end;
end;

In diesem Beispiel wird gezeigt, wie man den Text des Edits in das Memo schreiben kann.
Durch das 'Lines.Add' wird nach jedem Enter drücken der Text des Edits in eine neue Zeile des Memos geschrieben.

Passen sie das Hauptmenü so an:
- Datei
|- Neu
|- Öffnen
|- Speichern
|- Speichern unter ...
|- -
|- Beenden


Bitte fügen sie den SaveDialog, OpenDialog auf die Form ein.

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.Neu1Click(Sender: TObject);
begin
// Memo Inhalt löschen
Memo1.Clear;
// MainMenu1.Items[0].Caption := '&Sie haben gerade auf ein SubMenuItem geklickt!';
end;

procedure TForm1.ffnen1Click(Sender: TObject);
begin
 // OpenDialog anzeigen
 if OpenDialog1.Execute then
 { ein OpenDialog hat immer eine Zeile, die sich Filename nennt, dort wird angegeben, welche     
  Datei geladen werden soll. Das Memo hat eine Funktion, mit der man eine Datei einfach ins Memo 
  laden kann. Da der OpenDialog ja immer die ausgewählte Datei unter Filename einträgt, muss man nur
  OpenDialog1.Filename angeben. }
  Memo1.Lines.LoadFromFile(OpenDialog1.FileName);
end;

procedure TForm1.Speichernunter1Click(Sender: TObject);
begin
 // Das Selbe wie beim OpenDialog, bloß dass es gespeichert wird
 if SaveDialog1.Execute then
   Memo1.Lines.SaveToFile(SaveDialog1.FileName);
end;

procedure TForm1.Speichern1Click(Sender: TObject);
begin
  // falls
  try
  // überprüft, ob die Datei schon vorhanden ist und speichert
    if SaveDialog1.FileName <> '' then Memo1.lines.savetofile(SaveDialog1.FileName);
  // dann
  except
    // es wird eine Meldung ausgegeben, falls ein Fehler auftritt
    ShowMessage ('Fehler beim Speichern der Datei!');
  end;
end;

procedure TForm1.Beenden1Click(Sender: TObject);
begin
// Programm beenden
Close;
end;

Nun können sie schon Texte neu erstellen, speichern, öffnen und das Programm durch das MainMenu beenden.



- ListBox
Eine Listbox ist nichts anderes als eine normale Liste, auf die man zugreifen kann, z.B. Items hinzufügen entfernen. Jetzt wird es schon komplizierter. Im folgendem Beispiel wird gezeigt, wie man in eine Listbox Text-Dateien laden und speichern kann und sie wieder aus der Listbox entfernen kann (Items).

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.Button3Click(Sender: TObject);
begin
// ist uns schon vom Memo bekannt
if OpenDialog1.Execute then
  Listbox1.Items.Add(OpenDialog1.FileName);
end;

procedure TForm1.Button5Click(Sender: TObject);
var filename: string;
    ItemIndex: integer;
begin
// bevor Fehler auftreten abbrechen
  itemindex := ListBox1.ItemIndex;
  if ItemIndex = -1 then
    exit;
  // wir haben filename als Variable angegeben und müssen noch definieren,
  //was sie machen soll
  filename := ListBox1.Items.Strings[ListBox1.ItemIndex];
  // da der Pfad der Datei in der Listbox steht, müssen wir nur den oben
  // ermittelten filename laden
  // sie können mehrere Dateien in hinzufügen und dann beliebig eine auswählen
  // und es wird nur die ausgewählte geladen
  Memo1.Lines.LoadFromFile(filename);
end;

procedure TForm1.Button4Click(Sender: TObject);
var i: integer;
begin
// ausgewähltes Item löschen
i := ListBox1.ItemIndex;
if i >= 0 then
ListBox1.Items.Delete(i);
end;

procedure TForm1.Button6Click(Sender: TObject);
var i: integer;
begin
i := ListBox1.ItemIndex;
if i >= 0 then
// speichert alles auf die ausgewählte Datei ab
Memo1.Lines.SaveToFile(ListBox1.Items.Strings[ListBox1.ItemIndex]);
end;

Man muss die Begriffen wirklich können. Das kommt aber mit der Zeit.



- ComboBox
Es soll ja nicht zu kompliziert werden, deshalb nehm ich oft die selben Code-Beispiele um die vielen Möglichkeiten zu zeigen. Fügen sie eine ComboBox auf die Form und tippen sie in OnCreate
ComboBox1.Items ein. Fällt ihnen etwas auf ? Eine ComboBox ist eine Art ausklappbare Listbox. Damit ist doch schon viel gesagt ! Wir können mit der ComboBox fast so viel anstellen, wie mit der ListBox. Es ist geschmackssache, ob sie ComboBox oder ListBox nehmen. Für eine playlist im Player können/sollten sie aber eine ListBox nehmen, das macht es dem Benutzer leichter sich zurecht zufinden. Denken sie immer daran, das sich die Programme immer nach dem Benutzer richten müssen. Deshalb sollten auch mehrere Skins zur Verfügung stehen.
Löschen sie nun den eben hinzugefügten OnCreate-Code wieder (der war auch nur zum erklären).
Klicken sie hinter Items auf (TStrings). Nun erscheint ein kleines Editor-Fenster. Jetzt können sie Items hinzufügen (geht selbstverständlich mit ComboBox1.Items.Add('mach was')). Nun folgt eine kleine Liste, in der erklärt wird, in welche Zeile was rein kommt.
1. Hinzufügen
2. Entfernen
3. Laden
4. Speichern
Welche Methode wählen wir für den Code ? Soll er klein sein ? Nehmen wir die Methode, mit der man proceduren aufzuruft.

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.ComboBox1Click(Sender: TObject);
begin
//sobald man klickt wird überprüft, worauf man geklickt hat
//if ComboBox1.ItemIndex[0] then Button3Click(Sender);

// case = fall
// of = von
// danach kommen zahlen für index und das ereignis
case RadioGroup1.ItemIndex of
  0: Button3Click(Sender);
  1: Button4Click(Sender);
  2: Button5Click(Sender);
  3: Button6Click(Sender);
end;

end;

- Panel
Ein Panel ist eine Fläche mit der man alles überdecken kann. Fügen sie ein Panel auf die Form und stellen sie im Objectinspector BevelOuter und Bevelinner auf bvNone. Nun schneiden sie alle anderen Komponenten [Strg+X, Ctrl+X] aus und fügen sie in den Panel. Stellen sie Align auf alClient. Nun befinden sich alle Komponenten im Panel.



- CheckBox/RadioButton
Fügen sie vier RadioButtons der Form zu. Wenn mehrere RadioButtons da sind, kann man immer nur einen auswählen. Wenn man CheckBoxen hat, kann man alle auswählen.
In der folgenden Tabelle wird erklärt, welcher RadioButton eine bestimmte Beschriftung bekommt.
1. Entfernen
2. Hinzufügen
3. Laden
4. Speichern
Ich gebe ihnen jetzt keinen Code. Sie sollten nach der Beschrifftung wissen, was wo hinkommt. Tipp: An jedem RadioButton gibt es ein OnClick ereignis.



- RadioGroup
In eine RadioGroup kommen mehrere RadioButtons. Kopieren/schreiben sie folgenden Code in den Inhalt des Editors Items.

markieren

Code:

Hinzufügen
Entfernen
Laden
Speichern

Wie immer OnClick ...

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.RadioGroup1Click(Sender: TObject);
begin
// der selbe Code wie bei der ComboBox, bloß dass RdaioGroup1 davor steht
// case = fall
// of = von
// danach kommen zahlen für index und das ereignis
case RadioGroup1.ItemIndex of
  0: Button3Click(Sender);
  1: Button4Click(Sender);
  2: Button5Click(Sender);
  3: Button6Click(Sender);
end;

end;

- Popupmenu
Ein Popupmenü ist nichts als ein MainMenu, bloß das man es mit rechtsklick öffnet und es muss zugeordnet weden.
Fügen sie nun ein, was sie wollen und ordnen den OnClick-Ereignissen wieder etwas zu. In dem Beispielprogramm wird es nichts davon geben.



3: Ein kleiner Rechner
Dieses Programm kann addieren, subtrahieren, multiplizieren und dividieren.
Integer = Ganzzahl
Float = Kommazahl
Real = Kommazahl

Wir könnten einen Rechner programmieren, der nur Ganzzahl kann. Spätestens beim dividieren kommen die ersten Probleme. Da verlangt er nach 'real'.
Es kommen Variablen-umwandlungen vor:
StrToInt
IntToStr
FloatToStr
StrToFloat

Fügen sie 8 Buttons auf die Form ein.
1. +
2. -
3. *
4. /
5. =
6. =
7. =
8. =
Es müssen die letzten 3 '=' Buttons unsichtbar sein. Und der erste Enabled := True.
Vier mal '=' ? Warum ? Es ist die einfache Version mit Visible := True [man sieht den Button (False = man sieht den Button nicht)]
Fügen sie ein Edit auf die Form ein (machen sie Text einfach frei).
Enabled = drauf klicken und es passiert was (true), draufklicken und es passiert nichts (false)

Nun fangen wir an:
Globale Variablen stehen unter type. Es sollte jetzt so aussehen

markieren

Delphi-Quellcode:

var
  Form1: TForm1;
  zahl1, zahl2, ergebnis: real; // zahlen und ergebnis definieren

Name's der 4 '=' Buttons
1. ergebnisbut
2. ergebnisbut2
3. ergebnisbut3
4. ergebnisbut4

zusammenfalten · markieren

Delphi-Quellcode:

// OnCLick-Ereignis von dem plus Button
procedure TForm1.plusClick(Sender: TObject);
begin
// zahl1 ist die erste Edit eingabe (muss natürlich eine zahl sein)
// die Begriffe wie strtofloat sind schon oben erklärt.
zahl1 := StrToFloat(Edit1.Text);
//Edit inhalt löschen
Edit1.Clear;
//benötigten BUtton anzeigen und die anderen verstecken
ergebnisbut.Enabled := True;
ergebnisbut.Visible := True;
ergebnisbut2.Visible := False;
ergebnisbut3.Visible := False;
ergebnisbut4.Visible := False;
end;

// OnCLick-Ereignis von dem minus Button
procedure TForm1.minusClick(Sender: TObject);
begin
zahl1 := StrToFloat(Edit1.Text);
Edit1.Clear;
ergebnisbut.Visible := False;
ergebnisbut2.Visible := True;
ergebnisbut3.Visible := False;
ergebnisbut4.Visible := False;
end;

procedure TForm1.malClick(Sender: TObject);
begin
zahl1 := StrToFloat(Edit1.Text);
Edit1.Clear;
ergebnisbut3.Visible := True;
ergebnisbut4.Visible := False;
ergebnisbut2.Visible := False;
ergebnisbut.Visible := False;
end;

procedure TForm1.geteiltClick(Sender: TObject);
begin
zahl1 := StrToFloat(Edit1.Text);
Edit1.Clear;
ergebnisbut4.Visible := True;
ergebnisbut3.Visible := False;
ergebnisbut2.Visible := False;
ergebnisbut.Visible := False;
end;

procedure TForm1.ergebnisbutClick(Sender: TObject);
begin
// zweite Zahl festlegen (zweite eingabe)
zahl2 := StrToFloat(Edit1.Text);
// ergebnis als addition von zahl1 und zahl2
// wenn dort ein - steht, wird subtrahiert (kommt noch)
ergebnis := zahl1 + zahl2;
//ausgabe im edit
// variable muss umgewandelt werden
// sie können auch komma rechnen
Edit1.Text := FloatToStr(ergebnis);
end;

procedure TForm1.ergebnisbut2Click(Sender: TObject);
begin
zahl2 := StrToFloat(Edit1.Text);
ergebnis := zahl1 - zahl2;
Edit1.Text := FloatToStr(ergebnis);
end;

procedure TForm1.ergebnisbut3Click(Sender: TObject);
begin
zahl2 := StrToFloat(Edit1.Text);
ergebnis := zahl1 * zahl2;
Edit1.Text := FloatToStr(ergebnis);
end;

procedure TForm1.ergebnisbut4Click(Sender: TObject);
begin
zahl2 := StrToFloat(Edit1.Text);
ergebnis := zahl1 / zahl2;
Edit1.Text := FloatToStr(ergebnis);
end;

Ihr erstes Programm !

Die Typen müssen überall umgewandelt werden, weil sie nicht kompatibel zueinander sind.
Die procedure dectoroman müssen sie nicht verstehen. Sie ist halt nur ein Feature. Ich hab sie mal im Internet gefunden.

NOCH VIEL SPAß MIT DELPHI !

Es heißt "Standard" - nicht Standart

und zu deinen ComboBox/RadioGroup dingern

<wurst>

markieren

Delphi-Quellcode:

if RadioGroup1.Items.IndexOf(RadioGroup1.Items.Strings[RadioGroup1.ItemIndex])=0 then Button3Click(Sender);
if RadioGroup1.Items.IndexOf(RadioGroup1.Items.Strings[RadioGroup1.ItemIndex])=1 then Button4Click(Sender);
if RadioGroup1.Items.IndexOf(RadioGroup1.Items.Strings[RadioGroup1.ItemIndex])=2 then Button5Click(Sender);
if RadioGroup1.Items.IndexOf(RadioGroup1.Items.Strings[RadioGroup1.ItemIndex])=3 then Button6Click(Sender);

</wurst>

das kammer auch kürzer tüdeln

markieren

Delphi-Quellcode:

case RadioGroup1.ItemIndex of
  0: ;
  1: ;
end;

dasselbe auch beim ComboBox teil

das ".Strings" kammer sich auch sparen


</senf>

Du schreibst ein Anfänger Tutorial mit einem Kapitel Variablen. Du zählst kurz die Typen auf und das war's? Schön ich weis jetzt dass ich in einen Integer ne ganze Zahl speichern kann. Ich kann's aber net weil du net geschrieben hast wo man Variablen deklariert und wo, wie und warum man sie einsetzt. Sollte man verbessern!


mfg mr47

Erst einmal finde ich deine Mühen gut, ein Tutorial zu schreiben!

Dann erstmal die negative Kritik...

1. Ein Anfängertutorial, das sofort mit dem Formdesigner anfängt, halte ich für nicht besonders geschickt. IMHO verleitet das angehende Programmierer dazu, "Klickie-Buntie"-Programmierer zu werden, die es Programmieren nennen, wenn sie per Buttonklick einen Schriftzug erscheinen lassen können. Ich persönlich hab den Fehler selbst gemacht, und war auch lange Zeit dazu verleitet, eben dies zu machen. Die bessere Alternative ist imho, zuerst mit einfachen nonVCL-Programmen anzufangen, um Variablen und Konstanten, Funktionen und Prozeduren oder Schleifen zu erklären.

2. Du gehst beinahe im ganzen Tutorial nur auf die Verwendung der VCL-Komponenten ein. Noch dazu verwendest du Namen wie "Button", "Edit" oder "Label". Das sind falsche Bezeichner! richtig müsste man "TEdit" und "TLabel" sagen. Denn ein TEdit ist kein Edit und ein Label ist kein TLabel. Labels sind Sprachkonstrukte einiger Programmiersprachen, unter anderem auch in Pascal.

3. Wo hast du die Delphi-Language erklärt? Ich finde nur etwas zu allen Möglichen Komponenten. Wo werden Prozeduren beschrieben? Wo Funktionen? Wo werden Schleifen erklärt? Wo Konstanten? Wo werden Variablen erklärt? Oder willst du mir ernsthaft weiß machen, das Kapitel über Variablen soll alles gewesen sein?
Alles, was du da gemacht hast, ist ein paar Typen aufgezählt. Noch dazu hast du das falsch beschrieben.

Zitat von Nils_13:

Es gibt in Delphi verschiedene Variablen, die einen vollkommen andern Sinn haben.

Tipp: lerne erst einmal selbst Programmieren, bevor du Tutorials schreibst. "Byte" oder "Integer" sind keine Variablen! Es sind Typen! Das ist ein großer Unterschied!!!


Unten in deinem "Beispielprogramm" hast du einige Sprachkonstrukte erklärt. Aber auch die sind falsch erklärt.

Zitat von Nils_13:

Globale Variablen stehen unter type.

Eventuell solltest du auch Englisch lernen, damit du es verstehst... Was ist denn Type? Type ist das Englische Wort für "Typ". Unter Type werden Typen deklariert! Keine Variablen! (globale) Variablen werden im var-Abschnitt deklariert! Das ist etwas total anderes.

Dann zu deiner "DecToRoman"-Funktion. Wo hast du sie erklärt? Du hast eine Funktion geschrieben, und servierst sie den Anfängern, die nichts davon verstehen. Verstehen sie die konstanten Arrays? Verstehen sie die beiden Schleifen, die benutzt werden? Wissen sie, warum am Ende ":String" steht? Was die Klammern bedeuten?

Außerdem ist die Funktion nicht nur eine Funktion, sondern eine Methode. Du hast nirgendwo beschrieben, wie du sie deklariert hast.

Zitat von Nils_13:

Die procedure dectoroman müssen sie nicht verstehen. Sie ist halt nur ein Feature. Ich hab sie mal im Internet gefunden.

Wow. Das nenn ich ein Vorbild: Statt dir die Funktion selbst zu schreiben, kopierst du sie nur in das Tutorial? Damit verleitest du deine "Tutorial-Leser" nicht nur zu Klickie-Buntie-Programmierern, sondern auch noch zu Copy&Paste-Programmierern!

Zitat von Nils_13:

Nun laden sie sich bitte die glscene runter. In der RAR-Datei ist ein Beispiel. Wie sie Komponenten installieren können sie woanders nachfragen, aber bitte nicht hier. Es ist eine kleine Welt die sich drehen kann und die man, wenn man will, auch bei Nacht betrachten kann.

Noch so ein Super-Tipp. Du sagst deinen Tutorial-Lesern, sie sollen sich eine Komponentensammlung downloaden, ohne zu erklären:
- Was sie kann
- Wofür sie gut ist
- Was man damit macht

Außerdem ist es in keinster Weise ratsam, einem Anfänger (!!!) glScene vorzulegen. Und schon gar nicht nach diesem Tutorial.



Fazit: Dieses Tutorial lässt sich viel besser durch das Buch Delphi Ge-Packt ersetzen. Dieses bietet eine ausführliche Referenz der VCL-Komponenten, sowie deren Eigenschaften und Ereignisse. Nicht dies halbe Liste von Nils. Außerdem solltest du dich mal mit Rechtschreibung und Grammatik auseinandersetzen.
Sprachkonstrukte werden in diesem Tutorial stark vernachlässigt. Wir erfahren nichts (bzw. kaum etwas) über Variablen, "eigene" Typen, Records, Konstanten, Prozeduren, Funktionen, Schleifen, Pointer und/oder Operatoren. Man erfährt außerdem nicht, was Delphi ist, woher man es bekommen kann, wie teuer es ist etc. pp.
Meiner Meinung nach nicht für Anfänger geeignet.


PS: Nimm es mir bitte nicht böse, wenn es etwas "hart" klingt, aber diese Kritk musste einmal sein. Ich nenne so etwas übrigens "konstruktive" Kritik, indem ich dir einige der Schwächen des Tutorials nenne, die du bei Gelegenheit ausbessern kannst. Natürlich verstehe ich, dass man nicht alles in einem Tutorial zusammenfassen kann, aber man sollte wenigstens das wichtigste mit einbringen. Und das sind nicht die 15 VCL-Komponenten, die du ansprichst.

//edit: Ein paar Tippelfehler ausgebessert

NonVCL hab ich verlernt. Aber das mit procedure etc. stimmt. Hab noch viel zu tun.

@Nils: Bitte Quote doch nicht alles von mir <-- Hat sich wohl schon erledigt

Zitat von Nils_13:

NonVCL hab ich verlernt.

Erm... wie geht das? Du wirst doch wohl wissen, wie man ein Konsolenprogramm schreibt, dass eine entsprechende Ausgabe macht? nonVCL heißt ja nur "ohne VCL", das heißt unter anderem auch "ohne Formdesigner". Von daher gibt es da auch nicht viel zu verlernen... und wenn doch, dann hast du was nachzuholen.

Kenn mich da mit dem Design halt nicht aus. Allgemein hab ich einen interpreter in Konsole geschrieben... . Der hat halt nichts. Eine Konsole die siche nach dem Vorgang schließt.

Hallo Nils,

es ist nett, dass Du Dir die Mühe machst, ein Tutorial zu schreiben. Aber eine Bitte: Schreibe nur über Dinge, die Du selber vollständig begriffen hast. Ich denke, Du solltest vielleicht nicht mit einem "all-in-one" Tutorial anfangen, welches in einem Rundflug diverse Themen behandelt, sondern kapitelweise arbeiten und erst dann weitermachen, wenn ein Kapitel vollständig und richtig vorliegt.

Die derzeitige Fassung Deines Tutorials wird Anfänger leider mehr verwirren als ihnen helfen. Ein paar gute Beispiele findest Du zum Beispiel bei www.dsdt.info/grundlagen oder auch im dunklen Serverkeller des DF.

Nicht böse sein, aber die derzeitige Fassung Deines Textes kann man so nicht in der Tutorials-Sparte stehen lassen.

Du hast dir sicher viel Mühe gegeben, ich kann mich aber malo nur anschließen. Schreibe ein Konsolenprogramm mit möglichst wenigen Klassen oder Fuktionen und erkläre alle Einzelheiten genau.
Außerdem solltest du etwas mehr auf Code-Formatierung achten, im zweiten Teil fehlt die Einrückung fast komplett. Und wenn du nun einmal

markieren

Delphi-Quellcode:

var
  Form1: TForm1;
  zahl1, zahl2, ergebnis: real;

und anderswo
var i: integer; schreibst, verwirrst du nur deine Leser.

Noch etwas:
Tut.Text := StringReplace(Tut.Tex, 'sie', 'Sie', [rfReplaceAll]);

Ich habe die neue Rechtschreibung gelernt, da schreibt man sie klein.