Für Lazarus IDE sollten Grundkenntnisse der Programmierung vorhanden sein sowie Übung mit der Entwicklungsumgebung! Eine kleine Instruktion gibt es hier...

Typen, Meldungen und Felder Zeilen hinzufügen und zählen Einträge zählen und summieren Funktion: Parameter vertauschen
Progressleiste starten und anhalten Der Klick als Ereignis String mit zwei Prozeduren String mit einer Prozedur
Ereignisse eines Dialogs zählen Einträge der Liste selectieren Einträge per Checkbox Formen bewegen und skalieren
Formen animieren Klassen erzeugen Zeichen zählen case & if... else...

Die Variablen wurden global deklariert. Um negative Werte zu vermeiden, dient eine if Anweisung in der Prozedur der Differenz.

Achten Sie darauf, vor else kein Semikolon zu setzen. Pascal lässt grüssen! Und das Einsetzen der Werte in die Meldung erinnert an Java.

Es reicht, die Definition der verwendeten Variablen einmal in der Prozedur vorzunehmen:
a := StrToFloat(Edit1.Text) und eben b := StrToFloat(Edit2.Text)

Auch in der Meldung müssen die Werte, sofern sie Erwähnung finden, eine Typumwandlung erfahren! Einfache Benennungen der Variablen reichen nicht aus.

Beide Rechnungen brauchen letztlich die Definition Edit3.Text := FloatToStr(c)

Achten Sie auch hier auf die Definition der Typen und auf die Handhabe der for Schleife.

Die erste Definition weist i als Zählvariable den Startwert a zu und sonst nichts. Hier wird i mit a initialisiert. Danach wird a definiert und nicht mehr i. Und zwar so, daß der erste Wert von a nicht übergangen wird.

Dann ist im Programm ferner eine Bedingung, wenn man die Richtung des Zählvorgangs verwechselt; diese erklärt sich aber von selbst...

Wirklich wichtig ist das Kommando vor der Zählroutine Memo1.Clear, weil sonst alte Werte nicht überschrieben werden. Das Programm fügt dann durch Memo1.Lines.Add(IntToStr(i)) neue Zeilen einfach vorigen Zeilen an. Also erst löschen und dann zählen!

Dann kommt Edit3.Text := IntToStr ( Memo1.Lines.Count ) zwar ohne Deklaration einer Variablen aus - klar ist ein Spezialkommando - aber nicht ohne Typumwandlung.

Es werden immer zwei Werte addiert, die aktuelle Summe wird ausgegeben und die Anzahl der Rechnungen - eigentlich die Zeilen - mitgezählt. Dann kommt in das unterste Feld die Gesamtsumme aller Rechnungen. Dazu braucht man eine for Schleife

Hierzu werden die bisherigen Rechnungen ihrer Anzahl nach einbezogen und das geschieht mit i Typs Integer.

Zunächst wird i mit 0 initialisiert und dann ListBox1.Items.Count um das Attribut - 1 erweitert, damit der Name ListBox1 ausgeschlossen ist.

ges := ges + StrToInt(ListBox1.Items[i]); Edit5.Text := IntToStr(ges)

Zur Variablen der Summe ges wird immer der Wert des vorigen Eintrags addiert.
Und das i - mal; daher den Parameter [ i ] nicht vergessen. Beachten Sie auch die Typumwandlung.

Um auch hier negative Werte einer Differenz zu vermeiden, wird hier keine neue Rechnung angelegt sondern einfach nur die Parameter beim Aufruf der Funktion vertauscht.

So wird aus der Definition sum ( a, b ) einfach nur sum ( b, a )

Beachten Sie, daß dabei trotz der Funktion keine globalen Variablen verwendet wurden. Wichtig ist aber schon, wie immer die Datentypen in der Funktion zu deklarieren.

Die Definition result entspricht etwa dem return in C++. Es sind allgemeingültige Bezeichnungen und keine Variablen.

Nachdem c := sum( a, b ) definiert wurde, findet der erste Aufruf hier statt: Edit3.Text := IntToStr(c)

Sehr wichtig ist in Lazarus der Objectinspector bzw. die Werte des Timers und so darf der Anfangswert nicht false sein.

Dann wird 100 als Intervall eingestellt. Dadurch erspart man sich neben Wartezeit - die Voreinstellung ist nämlich 1000 - auch die Umrechnung in Prozent.

Der Kern des Programms ist allerdings ProgressBar1.Position := ProgressBar1.Position + 1 und der Wechsel zwischen Timer1.Enabled := true und false
Es werden hundert Additionen ausgeführt bis die if Anweisung mit ProgressBar1.Max zwar nicht dem Zählen ein Ende setzt, aber eine entsprechende Meldung ausgibt.

Um die Position des Balkens zu erfahren, muss man eine Variable einführen. Da immer 1 addiert wird, reicht als Datentyp ein Integer.

Um das Prinzip zu verdeutlichen, sollte man eher Absender sagen. Der Sender gibt das Objekt an, das ein Ereignis ausgelöst hat.

In unserem Fall kommt zwar nur der betreffende Button1 in Frage aber Sender steht hier trotzdem für ein Ereignis nach dem Motto true und somit ist kein Klick eben false

Alle foldenden Bedingungen hängen also vom Ereignis des Buttons ab, der nun mal der Absender des Werts true ist.

Beachten Sie, daß die Variable b mit ihrer Definition b := length(a) eine Zahl sein muss, da ja gezählt wird. Durch dieses Sonderkommando ist eine for Routine nicht nötig.

Nebenstehendes Programm nimmt einen String mit max. 15 Zeichen auf. Achten Sie auf die Deklaration der Variablen, worin der Parameter festgelegt wird.

Die Buttons Meldung oder eben Textfeld rufen jeweils eine eigenständige Prozedur auf.

Jeder Prozedur muß die Variable - hier lokal deklariert - bekannt sein. Wichtig ist auch, die Variable txt als Datentyp und Eingabefeld zu in beiden Prozeduren zu definieren.

Um das Textfeld zu leeren, wenn die Meldung ausgegeben wird, reicht die einfache Definition als Konstante Edit2.Text := 'Keine Anzeige.'

Weitere if... else... Anweisungen sind bei zwei Ereignissen nicht nötig.

Nun reicht eine Prozedur. Darin entscheidet eine if... else Anweisung über die Art der Ausgabe. Beide Modi lassen sich beliebig wechseln und kombinieren.

Auf den Button Eingaben löschen kann man hier verzichten, weil das Kommando Edit1.Clear sich schnell vermittelt.

Wichtig ist hingegen der boolsche Datentyp true ( Objektinspektor in Lazarus ) und setzen sie nach end kein Semikolon wegen else

Dann fällt noch auf, daß in der Meldung die Variable einfach als Benennung ausgegeben wird; also ohne Typumwandlung. Das macht hier Sinn, denn es ist bereits ein String und keine Zahl, die umgewandelt würde.

Z.B. bräuchte ein Float zwingend: ShowMessage( 'Meldung: ' + FloatToStr(a) ) ;

Checkboxes, Menues oder auch Dialoge halten Alternativen bereit, die über den weiteren Verlauf eines Programms entscheiden. Im Beispiel werden nur die Ereignisse im Dialog, die mit Yes quittiert wurden gezählt.

Der Aufruf eines Dialogs mit seinen Parametern ist der Kern des Programms:

MessageDlg('typundzahl.de', 'Dialoge mit Lazarus', mtConfirmation,[mbYes, mbNo], 0)

Libraries sind hier nicht nötig. Jedoch sind die Parameter mbYes und mbNo nicht veränderbar, sondern Standard.

Damit es nicht notwendig sein wird, den gesamten Dialog in eine if... else Anweisung zu schreiben, was das Ganze unübersichtlich macht, wird eine Variable a Typs Integer angelegt. Eigentlich ist der gesamte Dialog mit seinen Parametern durch die Definition nun ein Integer und man kann damit arbeiten.

Die Bedingung bezieht sich dann nur noch auf die Parameter mrYes oder mrNo und so steht hier mrYes für MessageResult und damit gezählt wird, dient im einfachsten Fall die Definition Button1.Tag := Button1.Tag + 1

Es wird bereits beim Einfügen der Einträge in ein separates Feld gezählt:

Edit2.Text := IntToStr( ListBox1.Items.Count )

In der ersten Prozedur braucht man noch keinen deklarierten Integer, während die zweite Prozedur ohne Zählvariable nicht auskommt, weil dann mit

if ListBox1.SelCount > 0 then... verglichen wird.

Der Zählvorgang der zweiten Prozedur ist sehr wichtig, da zunächst geprüft wird, ob überhaupt Einträge vorhanden sind. Ausserdem kann es sein, daß man versehentlich nichts ausgewählt hat und trotzdem einen speziellen Eintrag löschen möchte; für diesen Fall braucht man eine Anweisung: else impliziert hier ListBox1.Count <= 0

Und damit gelöschte Einträge aktualisiert werden in der zweiten Prozedur noch einmal Edit2.Text := IntToStr( ListBox1.Items.Count )

Startseite  |  Hinweise und Impressum  |  Facebook  |  Twitter  |  Google plus