Workshop 03: Funktionen
Ich hoffe, Sie haben den vorhergehenden Workshop, den über die Variablen gelesen. Ich weiss nicht, wie es Ihnen geht, aber ich habe einiges über diese vars gelernt. Dieses Kapitel lehrt nun viel Neues und hoffentlich auch Interessantes über Funktionen.
Was sind diese Funktionen überhaupt? Betrachten wir uns ein kleines Beispiel:
function add_numbers(
)
{
a
= 3;
b
= 5;
c
= a + b;
}
Sehen Sie was ich sehe? Eine Funktion ist nichts weiter als eine Sammlung von Befehlen. Sie besteht aus verschiedenen lite-C-Anweisungen, die vars und Ähnliches verwenden. Betrachten wir uns einige Eigenschaften von Funktionen:
1. Eine Funktion wird durch das Schlüsselwort function, gefolgt vom Namen der Funktion und einem anschließenden Paar Klammern ( ) definiert. Diese Klammern werden zur Übergabe zusätzlicher Parameter an die Funktion verwendet. In unserem Fall übergeben wir keine Parameter, also sind sie leer.
2. Die eigentliche Funktion (ihr Inhalt) muss innerhalb geschweifter Klammern { } stehen.
3. Die eigentliche Funktion besteht aus einer oder mehrere lite-C-Codezeilen, die jeweils mit einem Semikolon enden.
4. For Funktionsnamen gelten die gleichen Regeln wie für Variablennamen.
5. Sie dürfen nicht ein- und denselben Namen für eine Variable und eine Funktion benutzen; das führt zu Fehlern.
Wenn Sie in der Lage sind, dieses Tutorial zu lesen, wissen Sie hoffentlich auch Ihr Alter. Nicht in Jahren, in Tagen! Was, das wissen Sie nicht? Haben Sie Lust, eine Funktion zu schreiben, die diese Anzahl von Tagen berechnet? Ok, versuchen wir eine Funktion zu schreiben, die die Anzahl von Tagen, die ich (oder Sie) auf der Welt bin, berechnet. Wir werden einige vars brauchen, also definieren wir die am besten zuerst:
var my_age = 33; // hierher gehört
Ihr Alter (in Jahren)
var days_a_year = 365;
var number_of_days;
Soweit nichts neues, stimmt's? Wir haben drei vars definiert und zwei davon haben Anfangswerte erhalten, denn schließlich weiss ich mein Alter in Jahren und ich weiss außerdem, dass fast jedes Jahr 365 Tage hat. Ich bin ein bisschen nervös - ob diese Funktion auch funktioniert?
Ich weiss, wie ich anfangen muss! Ich schreibe das Schlüsselwort function und dann den Namen der Funktion; nennen wir sie compute_days:
function compute_days()
{
Ich habe die Klammern nach dem Funktions-Namen
nicht vergessen und ich habe die erste geschweifte Klammer eingetippt!
Jetzt kommt der Teil, vor dem ich mich ein
wenig fürchte: wie kann ich der Engine klarmachen, dass sie die
Anzahl der Tage berechnen soll? Moment... wie würde ich das mit
einem Taschenrechner machen? Ich würde es ungefähr so machen:
number_of_days = 33 x 365 // number_of_days ist nur ein Name für's Ergebnis
Werfen wir nun einen Blick auf unsere vars: wenn ich 33 durch my_age ersetze und 365 durch days_a_year, bekomme ich in etwa sowas:
number_of_days = my_age x days_a_year
Diese Zeile fängt an nach lite-C auszusehen, allerdings müssen wir noch zwei kleinere Fehlerchen beseitigen:
- lite-C verwendet * zum multiplizieren und nicht x
- Jede Codezeile in lite-C muss mit einem Semikolon beendet werden
Ok, jetzt sollte unsere Funktion so aussehen:
function compute_days()
{
number_of_days =
my_age * days_a_year;
}
(Zwar spricht die Engine englisch - z.B. bei den Schlüsselworten, das gilt jedoch nicht für die Namensgebung durch den Anwender. In dieser Hinsicht ist die Engine multilingual und akzeptiert alles, auch deutsch. Daher stimmt's auch, wenn Ihre Funktion z.B. aussieht:
function berechne_Tage()
{
Anzahl_von_Tagen
= Alter * Tage_pro_Jahr
}
Der Faulheit des Übersetzers wegen und nicht weil es so sein müsste, sind die in diesem Handbuch nur die Kommentare übersetzt. Anm. d. Übers.)
Ich habe daran gedacht, die zweite geschweifte Klammer hinzuzufügen und somit ist der Inhalt der Funktion wie vorgeschrieben von den zwei erforderlichen geschweiften Klammern eingerahmt. Ich bin wirklich neugierig ob diese Funktion auch richtig arbeitet und daher habe ich auch schon eine kleine Skript-Datei für unsere Tests vorbereitet. Starten Sie Lite-C und öffnen Sie die Datei script03, welche sich im Ordner namens workshop03 befindet:
//////////////////////////////////////////////////////////////////// #include#include var my_age = 33; var days_a_year = 365; var number_of_days; // diesen Wert müssen wir berechnen //////////////////////////////////////////////////////////////////// PANEL* pDisplay = { digits (10, 10, 5, *, 1, number_of_days); flags = SHOW; } /////////////////////////////////////////////////////////////////////
Der Code sieht ziemlich einfach aus, nicht? Wir wissen bereits wie man mit diesen vars umgeht, wir wissen, wie man Kommentare dazuschreibt... Kopieren wir die Funktion compute_days doch gleich aus diesem Dokument und fügen sie ins Skript ein: markieren Sie den gesamten Text der Funktion mit der Maus, klicken Sie rechts, wählen Sie Copy, wechseln Sie zu Lite-C, klicken am Ende des Skripts mit rechts und wählen dann zum Einfügen der neuen Funktion Paste:
//////////////////////////////////////////////////////////////////// #include#include var my_age = 33; var days_a_year = 365; var number_of_days; // diesen Wert müssen wir berechnen //////////////////////////////////////////////////////////////////// PANEL* pDisplay = { digits (10, 10, 5, *, 1, number_of_days); flags = SHOW; } ///////////////////////////////////////////////////////////////////// function compute_days() { number_of_days = my_age * days_a_year; }
Machen wir einen Testlauf
mit unserer Skript-Datei:
Es läuft... aber es passiert gar nichts! Ich kann einen schwarzen Bildschirm sehen und ich sehe eine Null... ich bin null Tage alt? Ich hielt mich doch für wesentlich älter!
Irgendwas an dem Code kann da nicht stimmen... Ich weiss, dass ich die Funktion korrekt kopiert habe! Was soll ich tun?
Nun, wir haben eine Funktion geschrieben, die eigentlich auch korrekt funktionieren müsste, allerdings haben wir vergessen, sie auch zu starten, damit sie läuft. Stellen wir uns vor, Sie haben Geburtstag und mieten eine Band. Die Leute kommen zu Ihnen nachhause, setzen sich untätig in eine Ecke und warten auf Ihr Kommando. Und Sie stehen herum, sagen ihnen nicht, dass sie mit dem Spielen anfangen sollen und wundern sich, dass Sie keine Musik hören.. dasselbe geschieht mit unserer Funktion: wir schreiben sie aber wir müssen ihr auch das Startkommando geben.
Ok, so kommen wir weiter: und wie bringe ich meine neue Funktion jetzt zum laufen? Schreiben wir, wie unten angegeben, innerhalb einer neuen Main-Funktion eine Zeile, die die Funktion aufruft:
//////////////////////////////////////////////////////////////////// #includeZeit für einen neuen Testlauf...#include var my_age = 33; var days_a_year = 365; var number_of_days; // diesen Wert müssen wir berechnen //////////////////////////////////////////////////////////////////// PANEL* pDisplay = { digits (10, 10, 5, *, 1, number_of_days); flags = SHOW; } ///////////////////////////////////////////////////////////////////// function compute_days() { number_of_days = my_age * days_a_year; } function main() { screen_color.blue = 150; compute_days(); }
Gut, diesmal klappt es. Allerdings weiss ich nicht recht, was passiert ist. Ist die Funktion function main( ) irgendwie besonders oder was? Ja, main ist ein vordefinierter Funktionsname, also kommen Sie nicht auf die Idee, eine andere Funktion mit dem Namen main zu erstellen. Diese spezielle Funktion läuft jedesmal bei Spielstart von selbst. Schauen wir uns den Code in "main" einmal an:
function
main()
{
screen_color.blue
= 150;
compute_days();
}
So wie ich das sehe, ruft der Code, nachdem er die Bildschirmfarbe gesetzt hat, unsere Funktion auf (die daraufhin startet). Da wir schon einmal hier sind, betrachten wir uns doch gleich wie man eine Funktion aufruft: wir schreiben ihren Namen gefolgt von einem Paar Klammern und beenden die Lite-C-Skriptzeile mit einem Semikolon; klingt eigentlich logisch.
Wichtiger Hinweis: schreiben Sie den Code für Ihre Funktionen zuerst und rufen Sie ihn später auf. Die Engine liest den Code genauso, wie Sie ein Buch lesen: sie fängt oben auf der Skriptseite an und geht dann, den Code Zeile für Zeile lesend, runter bis zum Ende. Schreibe ich mein Skript auf diese Weise...
function
main()
{
compute_days();
}
function
compute_days()
{
number_of_days
= my_age * days_a_year;
}
... wird die Engine sagen: 'oh, das ist "fuction main", ich kenne "function main", die muss ich immer laufen lassen. Was kommt als nächstes? compute_days(). Was ist damit? Ich kenne diese Funktion nicht, ich weiss nicht, was die von mir will. Ich werde eine Fehlermeldung anzeigen und den Rest des Tages frei nehmen:
Denken Sie also dran, Ihre Funktion zuerst zu definieren und erst später aufzurufen. Andernfalls wird sich die Engine beim ersten Anwendungsversuch beschweren.
Ach übrigens: was hat es eigentlich mit diesen seltsamen Zeilen
#include <acknex.h>
#include <default.c>
... auf sich, die immer am Anfang des Codes auftauchen? #include fügt unserem Programm ein weiteres Stück Code hinzu. acknex.h ist der Standardcode, den wir einem Pure Mode-Programm immer hinzufügen müssen. Er enthält alle vordefinierten Variablen und Engine-Funktionen. In default.c finden sich einige oft gebrauchte Funktionen wie der Konsolenmodus aus der letzten Lektion und die Fähigkeit das Programm per [Esc] zu verlassen. Beide Dateien finden sich im iclude-Ordner. Lassen Sie die Zeile '#include <default.c>' weg und [Esc] funktioniert nicht mehr. Wenn der Beginn unseres Skripts gar kein #include enthält, werden allerdings beide Dateien automatisch included.
Sie sind ganz wild drauf, mehr zu lernen? Unsere Reise durch die wunderbare Welt des lite-C stellt sich als ziemlich einfach heraus, hab' ich recht? Im nächsten Workshop lernen wir wie man Panels erstellt. Panels sind Elemente, die alle möglichen Formen, Balken usw. darstellen können. Wann immer Sie ein Bild oder eine andere grafische Darstellung auf Ihrem Bildschirm sehen, steckt eine Paneldefinition dahinter.