Purebasic
Aus Wikibooks
Dieses Buch steht im Regal Programmierung.
Inhaltsverzeichnis |
[Bearbeiten] Einstieg
[Bearbeiten] Über dieses Buch
Das Buch ist für Anfänger bestimmt, die erste Schritte in die Purebasic-Programmierung wagen möchten. Purebasic ist für Einsteiger sowie für Profis gleichermaßen geschaffen und beherrscht viele Features, sodass es sich nicht vor anderen Programmiersprachen verstecken muss. Wegen des Umfanges der Programmiersprache Purebasic kann ich hier nicht alle Befehle, geschweige denn Regeln oder Kniffe lehren. Ich vermittle nur die Grundlagen, die unbedingt benötigt werden und für den Einstieg hilfreich sind.
An diesem Buch wird noch gearbeitet!
[Bearbeiten] Wer kann Purebasic gebrauchen?
Es ist für Menschen bestimmt, die schnelle Erfolge erzielen möchten, aber genauso für Fortgeschrittene, die schnell und einfach an irgendein Ziel gelangen möchten.
[Bearbeiten] Was kann Purebasic?
Purebasic ist, wie der Name schon sagt, erweitertes Basic, das (im Gegensatz zu den anderen Basic-Dialekten) sehr schnellen, optimierten Code produziert und mit C konkurrieren kann. Purebasic kompiliert sehr schnell (300.000 Zeilen/Minute auf einem Pentium 200) und erzeugt sehr optimierten Code. Mit Purebasic kann man fast alles programmieren, was man mit anderen Sprachen auch könnte. Die Standardbibliothek ist mit allen notwendigen Befehlen ausgestattet, wie zum Beispiel:
- Zeichenanweisungen
- Konsolenbefehle
- Standard-GUI-Befehle
- Abspielen von Mediendaten (CDs, MP3, AVI)
- Benutzereingabe
- Befehls-Bibliothek für Bildschirme, Sprites (Kleine Bilder)
- Inkludierte 3D Engine
- Lesen und Speichern von Daten
- Direkte Nutzung von Windows-API Befehlen
Zusätzlich hat Purebasic eine (alte) Version der OGRE 3D-Grafik Engine mit in den Befehlen integriert, die man auch nutzen kann. Mit einigen Befehlsbibliotheken kann man ASM(gesprochen: Assembler)-Code direkt eingeben und den Code weiter optimieren lassen (überspringen von nicht benötigten Befehlen).
Purebasic-Code kann auf folgenden Systemen kompiliert werden, ohne den Sourcecode (Quelldatei des Programms, das man erstellen möchte) für Windows, Linux, AmigaOS und Später Mac Kompilieren.
[Bearbeiten] Was kann man mit Purebasic programmieren?
Wie ich oben schon erwähnt hatte, kann man relativ einfach 3D-Applikationen (Spiele, Simulationssoftware, ...) sowie Windows-Applikationen erstellen (mit einer Benutzeroberfläche). Man kann genauso Büro-Software programmieren, die mit großen Datenmengen zurechtkommen muss.
Es ist auf Windows auch möglich Consolen Progamme und DLLs[1] zu erstellen. Zudem gibt es auch Versionen für Linux[2], MacOS[3] und AmigaOS[4].
[Bearbeiten] Grundlagen
[Bearbeiten] Allgemeine Grundlagen
Ein paar ganz wichtige Syntaxregeln sind zu beachten:
PureBasic arbeitet Zeilen orientiert, vom Zeilenanfang bis zum Zeilenende. Das heißt, ein in einer Zeile begonnener Befehl, muss auch in dieser Zeile enden. Man muss also sehr lange Befehle in eine Zeile schreiben. Ein aufteilen eines Befehles auf Zwei oder mehrere Zeilen geht also nicht, da es keinen Zeilenverbindungs-Operator gibt.
Leerzeichen im Code wie das Space(Leertaste) oder das TAB, werden vom Compiler so behandelt als wären sie nicht vorhanden.
Kommentare werden immer mit einem Semikolon (";") eingeleitet. Alles vom Semikolon bis zum Zeilenende wird dann vom Compiler Ignoriert. Benutzen Sie dieses reichlich, um sinnvolle Erläuterungen zu schreiben, was dieses Programm zum Beispiel tut und was man dabei beachten muss usw.
Code:
;Das ist ein KOMMENTAR
Man kann muss zwar einen begonnenen Befehl in einer Zeile auch beenden, man kann aber auch mehrere Befehle auf einmal auf eine Zeile schreiben (die dann wieder in dieser Zeile enden müssen). Dazu gibt es das :-Zeichen (Doppelpunkt). Das wird vom Compiler wie ein Anfang einer neuen Zeile behandelt.
Code:
a + c : c + 1 ; das führt zwei Compileranweisungen (Tokens) auf einer Zeile aus.
Um bei einer großen Programmdatei auch mitzubekommen, was das Programm macht, oder wo Fehler entstehen, gibt es den DEBUGGER. Der Debugger ist zum internen Fehlerabfangen da, also zum Beispiel bei folgenden Fehlern:
- Überlauffehler
- Division mit Null
- Multiplikation mit Null
- ...
Zusätzlich kann man mit dem Debugger auch Inhalte (Werte) von Variablen oder Text (in form von so genannten "Strings") ausgeben. Damit kann man kontrollieren was das Programm während es abläuft (zur Laufzeit) macht, und welchen Wert eine Variable zu welchem Zeitpunkt hat. Das geht mit folgendem Code:
Code:
;Hier wird dem Debugger ein Text zugeschickt: Debug "Das ist der Text, der angezeigt wird" ;Hier wird der Wert einer Variablen ausgegeben: Test = 1 Debug Test
Vorsicht: Die Debuginfos werden nur bei eingeschaltetem Debugger angezeigt. Ist der Debugger eingeschaltet ist die Ausführung des Programms ungefähr 6mal langsamer als die endgültige Version ohne Debugger. Ohne Debug-Informationen ist die Programmdatei (EXE-Datei) auch deutlich kleiner. Wenn Sie die richtige finale Version des Programms ohne Debugger kompilieren, werden die Debuginfos vom Compiler ignoriert und weggelassen. Das entfernen der Debug Befehle ist also nicht nötig.
[Bearbeiten] Variablen und Konstanten
Variablen sind, wie der Name schon sagt, Werte, die variieren können. Man kann im Programm ihnen jeden möglichen (nach dem Datentyp) Wert immer wieder zuweisen.
Dabei kann man bei der ersten Deklaration der Variable den Variablentyp gleich mit zuweisen. Der Variablentyp gibt Auskunft über die mögliche Verwendung der Variable und ggf. ihren Eigenschaften.
Arten und Eigenschaften der Variablentypen:
| Name | Endung | Speichergröße | möglicher Bereich |
|---|---|---|---|
| byte | .b | 1 Byte | -128 - 127 |
| Character | .c | 1 Byte (Ascii) | 0 bis +255 |
| Character | .c | 2 Byte (Unicode) | 0 bis +65535 |
| word | .w | 2 Byte | -32768 - 32768 |
| long | .l | 4 Byte | -2147483648 - 2147483647 |
| float | .f | 4 Byte | beliebig |
| string | .s | Länge des Strings + 1 | unlimitiert |
| Fixed (fester) String | .s{Länge} | Länge des Strings | unlimitiert |
| Quad | .q | 8 Byte | -9223372036854775808 bis +9223372036854775807 |
| Double | .d | 8 Byte | unlimitiert |
Beispiele für Deklarationen von Variablen mit Datentypen:
string.s textstring.s floatzahl.f wordzahl.w
Konstanten können im Gegensatz zu Variablen nur einmal festgelegt werden. Das ist zum Beispiel für Werte, die sich nie verändern, nützlich! Konstanten besitzen im Gegensatz zu Variablen keinen Variablentyp.
Codebeispiel:
a = 20 Debug a
Beschreibung: Dieser Code weist in der ersten Zeile der Variable a den Wert 20 zu, in der zweiten Zeile wird a im Debugfenster ausgegeben.
Codebeispiel(2):
#a = 15 Debug #a
Beschreibung: Dieser Code weist in der ersten Zeile der Konstante a den Wert 15 zu, in der zweiten Zeile wird die Konstante a ausgegeben!
Variablen können allgemein zum Steuern des gesamten Programms verwendet werden. Grundsätzlich gilt, dass in PureBasic alle nummerischen Variablentypen signed sind, das heißt, dass sie ein Vorzeichen haben!
[Bearbeiten] Structures
Structures (zu Deutsch Strukturen) muss man sich als Aufbewahrungort für mehrere Variablen vorstellen, die irgendetwas miteinander zu tun haben, z.B. die Daten einer Person. Man nutzt Structures also zum Speichern mehrerer Variablen unter einem gemeinsamen Namen:
Code:
Structure Person nachname.s vorname.s geburtsjahr.w Endstructure
Beachte:
Jede Variable innerhalb der Structure muss einen Typ zugewiesen bekommen.
Man kann nun eine neue Structure anlegen, die den Inhalt der Structure Person beinhaltet:
Code:
erstePerson.Person
Dabei wird die Structure referenziert, d.h. sowas wie nachgestellt.
Man kann nun die Variablen in der Structure Werte zuweisen.
Code:
erstePerson\nachname = "Mustermann" erstePerson\vorname = "Erika" erstePerson\geburtsjahr = 1977
[Bearbeiten] Konsolengerichtete Ein- und Ausgabe von Daten
Es gibt generell in PureBasic einfache Befehle, so auch hier. Um ein Konsolen-Fenster zu öffnen, muss man nur Folgendes eingeben:
Code:
If Openconsole() ;erfolgreich Else ;nicht erfolgreich, Programm beenden: END Endif
[Bearbeiten] Operationen
[Bearbeiten] Funktionen
Algemein:
Funktionen sind definierbare Befehle, die mehrere Befehle (die wiederrum durch Funktionenaufrufe) nacheinander ausführen können, so kann man flexible Programme schreiben, die viel weniger Platz brauchen, als wie wenn man alles ausschreiben würde. Außerdem erleichtert das Gliedern des Programmes in Funktionen auch das Finden von Bugs(Programm[ier]fehler), die manchmal auftreten. Grundsätzlich gilt, dass Funktionen eigene Variablen verwenden, d.h., dass, wenn man im Hauptprogramm zum Beispiel der Variable a den wert 24 gegeben hat und in der Funktion die vermeintlich selbe Variable a aufruft, hat die Variable a in der Funktion den Wert 0, weil die Variablen in den Funktionen von den Variablen in anderen Funktionen oder im Programm unabhängig sind, außer man definierte die Variable a mit dem GLOBAL-Schlüsselwort; dann würde nämlich die Variable a im ganzen Programm als ein einzige Variable gelten.
Ein einfaches Beispiel zu Verdeutlichung der Funktionssyntax, sowie der Schreibweise und der zu beachtenen Regeln: Code:
Procedure Plus (a,b) ergebnis = a + b ProcedureReturn ergebnis EndProcedure Debug plus(10,10)
Zuerst weisen wir mit dem Befehl Procedure dem Plus die Funktion mit den Variablen a und b zu. In der zweiten Zeile rechnen wir a plus b und erhalten das Ergebnis ergebnis, dann geben wir beim eventuellen Aufruf der Procedure noch den Rückgabewert an, in diesem Fall die Variable ergebnis. Mit Endprocedure wird die Procedure geschlossen und somit zum Benutzen freigeschaltet. In der letzten Zeile geben wir das Ergebnis der Procedure im Debugger aus.
[Bearbeiten] Kontrollbefehle
Die Kontrollbefehle benötigt man für das interaktive Steuern und Anspringen von Programmteilen je nach gegebener Situation.
Syntax:
Die Bedingung ist ein Ausdruck, der entweder erfüllt (true) oder unerfüllt (false) sein kann. Man kann zwei Werte miteinander vergleichen (wert1 = wert2); wenn sie gleich sind, ist die Bedingung erfüllt, also wahr (der Abschnitt wird ausgeführt), wenn sie nicht gleich sind, ist die Bedingung nicht erfüllt oder nicht wahr (der Abschnitt wird nicht ausgeführt).
Dasselbe funktioniert auch mit den Vergleichsoperatoren >, <, >= und <=.
Man kann auch nur eine Variable an der Stelle der Bedingung schreiben. Wenn sie ungleich 0 ist, ist die Bedingung wahr, andernfalls ist sie unwahr.
[Bearbeiten] If-Block
Syntax:
If bedingung ... [elseif] bedingung ... [else] ... Endif
If-Blöcke werden zum Verzweigen von Programmteilen je nach gegebener Situation eingesetzt. Wenn die Bedingung erfüllt ist, wird der Abschnitt ausgeführt.
[Bearbeiten] Select-Endselect-Block
Der Select-Endselect-Block wird zum Verzweigen des Programmes je nach Variablenwert eingesetzt. Syntax:
Select variable
Case wert
...
[default]
...
EndSelect
Case gibt eine Bedinung vor, die die Variable erfüllen kann. Wenn sie sie erfüllt, wird der Programmblock innerhalb des Case-Blockes ausgeführt, andernfalls wird er übersprungen. Default ist optional und wird dann ausgeführt, wenn alle Case-Anweisungen fehlschlugen.
Hinweis:
Es wird nur ein und zwar der erste Case-Block, bei dem die Variable die Bedingung erfüllt, ausgeführt.
[Bearbeiten] For-Next-Schleife
Syntax:
For variable = wert to wert2 [step wert] ... next
Eine for-next-Schleife setzt zu Beginn die Variable auf den Startwert wert. Bei jedem Durchgang des Blockes wird die Variable entweder, wenn step nicht da ist, um 1 erhöht oder aber, wenn step da ist, um den Wert oder der Variable nach step erhöht. wenn die Variable wert2 ereicht hat, wird die Schleife beendet.
[Bearbeiten] Repeat-Until-Schleife
Syntax:
Repeat ... Until bedingung
Die Repeat-Until-Schleife wird solange durchlaufen, bis die bedingung wahr ist.
[Bearbeiten] Foreach-Next-Block
Syntax:
Foreach linkedlist() ... Next
Die Foreach-Schleife führt die Vorgänge in dem Block für jedes Element der Linkedlist() aus.
[Bearbeiten] While-Wend-Schleife
Syntax:
While bedingung ... Wend
Der While-Wend-Block wird solange durchlaufen, bis die Bedingung falsch ist.
[Bearbeiten] Break-Continue-Befehle
Syntax:
break [breaklevel]
Der Break-Befehl wird benutzt, um aus dem aktuellen Repeat- ,For- ,Foreach- oder While-Block einfach auszusteigen. Der breaklevel ermöglicht mehrfaches Aussteigen (bei geschachtelten Blöcken).
Der Continue-Befehl wird zum Überspringen des aktuellen Durchganges bei einem Repeat- ,For- ,Foreach- oder While-Block eingesetzt.
[Bearbeiten] Gosub-Return-Befehle
Syntax:
Gosub aufgabe end aufgabe: ... Return
Der Gosub-Befehl springt von der aktuellen Programmzeile zum angegebenen Label. Dort wird die Programmausführung bis zum Return fortgesetzt. Das Return springt wieder zurück zum Gosub-Befehl und das Programm wird vom GoSub-Befehl weiter ausgeführt (in diesem Falle wird es beendet). Es bleibt jedoch anzumerken, dass es mittlerweile sehr verpönt ist, auf diese Weise zu programmieren, da hierdurch die Entstehung des sogenannten Spaghetticodes gefördert wird. Eleganter sind oben genannte Kontrollstrukturen oder die Auslagerung in Prozeduren.
[Bearbeiten] Fortgeschrittene Themen
[Bearbeiten] Zeiger (Pointer)
Ein Pointer oder auch Zeiger ist ein Wert, der eine Adresse im physikalischen Speicher (dem RAM) beschreibt. Er "zeigt" quasi auf diese Variable.
Code:
a = 20 *pointer = @a Debug a Debug *pointer
Dieser Code weist in der ersten Zeile der Variable a den Wert 20 zu und in der zweiten Zeile bekommt die Variable pointer den Pointer (die Speicheradresse) von a mittels dem "@"-Zeichen. In den letzten zwei Zeilen wird die Variable a und die Speicheradresse von a, gespeichert in pointer, ausgegeben. Das "*" am Anfang der Variable pointer wird nicht zwingen benötigt, dient aber der Übersicht und wird es einfacher gestalten Programme für 64 Bit zu programmieren.
[Bearbeiten] Peek & Poke
Nur für fortgeschrittene Programmierer!
Diese Befehle können zum direkten Eingriff in die Speicherzellen des Rechners benutzt werden.
Peek
Auslesen eines Wertes bzw. eines Strings aus den angegebenen Speicherzellen
Wert.b = PeekB(*SpeicherBuffer)
PeekB() liest einen Byte-Wert (1 Byte) aus der angegebenen Speicheradresse.
Das B kann durch unten stehende Buchstaben (Typen) ersetzt werden.
Beispiel:
String.s = "das ist eine Zeichenkette" For i = 0 To Len(String) Debug PeekS(@String+i,1) Next
Poke
Schreiben eines Wertes bzw. eines Strings in die angegebenen Speicherzellen
PokeB(*SpeicherBuffer, Nummer.b)
PokeB() schreibt einen Byte-Wert (1 Byte) in die angegebene Speicheradresse.
Das B kann durch unten stehende Buchstaben (Typen) ersetzt werden.
Beispiel:
*Buffer = AllocateMemory(Len("Zeichenkette")+1)
PokeS(*Buffer,"Zeichenkette")
For i = 0 To Len("Zeichenkette")
Debug PeekS(*Buffer+i,1)
Next
Typen: Werte-Bereich B = Byte 1Byte von -128 bis 127 oder positive Ganzzahlen von 0 bis 255 C = Character 1Byte (Ascii) von 0 bis +255 C = Character 2Byte (Unicode) von 0 bis +65535 W = Word 2Byte von -32768 bis +32767 L = Long 4Byte von -2147483648 bis +2147483647 F = Float 4Byte ohne Beschränkung Q = Quad 8 Byte von -9223372036854775808 bis +9223372036854775807 D = Double 8 bytes ohne Beschränkung S = String Länge des Strings + 1 bis zu 64000 Zeichen
[Bearbeiten] Array
Es gibt in Purebasic zwei Arten von Arrays, dynamische und statische. Die Größe von dynamischen Arrays kann man im Programmablauf ändern, was bei den statischen Arrays nicht der Fall ist, da die Größe des statischen Arrays bei der Deklaration der Array-Variablen festgelegt wird. Arrays können je nach Bedarf eindimensional oder mehrdimensional erzeugt werden. Um sich vorstellen zu können, was der Unterschied zwischen einem eindimensionalen und einm mehrdimensionalem Array ist, müssen wir uns ein Blatt kariertes Papier vorstellen, bei dem jedes Kästchen einen Arrayindex (Arrayfeld) beinhaltet. Ein eindimensionales Array wäre nach dem Model nur eine Kästchenreihe, die von der Linken Seite bis zur rechten Seite aber nur auf einer Zeile ausfüllbar ist. Bei einem mehrdimensionalen Array (in diesem Beispiel mit zwei Dimensionen) ginge der beschreibbare Bereich von oben links bis unten rechts, sodass wir jedem Kästchen auf dem karierten Papier eine Array-Indexadresse zuweisen können, zum Beispiel 15,40 (15 Kästchen (x) nach rechts und 40 Kästchen nach unten (y)), was eine eindeutige Adresse des Kästchens beschreibt, auf das man zugreifen kann.
Wir erzeugen ein statisches Array und greifen darauf zu:
Statische Arrays müssen in Structures eingebunden werden.
Code:
Structure test Name.s[10] EndStructure erste.test erste\Name[0] = "test" erste\Name[9] = "testing" ; Debug erste\Name[0] Debug erste\Name[9]
Mit den ersten drei Zeilen legen wir zuerst eine Structure an, die das statische Array Name.s mit 10 Feldern enthält. Dannach legen wir in der vierten Zeile eine neue Structure mit dem Namen erstes an, die aus der Grundstructure test besteht. In der 5. Zeile weisen wir dem Structurenfeld Name bei dem 0ten Arrayindex den text "test" zu. Danach weisen wir dem gleichen structurenfeld bei dem neunten Arrayindex den text "testing" zu. In der achten Zeile geben wir den Inhalt des Structurenfelds Name bei dem 0ten Arrayindex der Structure erste in den Debugger aus. In der neunten Zeile tun wir dasselbe mit dem neunten Arrayindex des Arrays Name in der Structure test.
[Bearbeiten] Strings
Strings sind Zeichenketten, die je nach Länge entsprechend viel Speicher benötigen. Zeichenkette bedeutet in diesem Fall, dass es Text ist.
Um einen String zu erzeugen, muss man nur Folgendes tun:
Code:
teststring.s ;Eine Stringvariable mit dem Namen teststring deklarieren (Dem System bekannt machen) teststring = "Teststring" ;Der Variable den String "Teststring" zuweisen Debug teststring ;Und den String im Debugfenster ausgeben
Zuerst wird dem String teststring.s der Inhalt (hier geht man vom Text aus) "Teststring" zugewiesen. Und in der darauf folgenden Zeile wird er im Debugger ausgegeben, allerdings ohne Anführungsstriche. Warum? Weil die Anführungsstriche den Anfang und das Ende einer Stringdeklination kennzeichnen; also nach dem ersten Anführungsstrich beginnt die Stringzuweisung und nach dem zweiten das Ende der Stringzuweisung.
Man kann Strings auch einfach miteinander verbinden; das sähe dann ungefähr so aus:
Code:
leer.s = " " Das.s = "Das" ist.s = "ist" ein.s = "ein" zusammen.s = "zusammengesetzter" string.s = "string" erg.s = Das + leer + ist + leer + ein + leer + zusammen + leer + string Debug erg
In den ersten 6 Zeilen werden den einzelnen Stringnamen die Texte zugewiesen, und in der siebenten Zeile wird der String "erg.s" durch Additionszeichen aus den anderen Strings erzeugt und schließlich mit debug erg.s ausgegeben. Das Additionszeichen ist dafür da, dass der Computer weiß, dass er die Strings nacheinander zusammensetzen muss.
[Bearbeiten] Linked Lists
Linked Lists sind "Elemente", die dynamisch je nach Speichergebrauch des Programms angelegt und gelöscht werden können (der ganze Speicher könnte rein theoretisch für Linked Lists benutzt werden). Ein "Element" benötigt pro Stück soviel Speicher wie die Variablen, die in dem Element sind. Folgendes Beispiel zu Demonstration:
Code:
Structure Element elementvariable.l Endstructure Newlist Element.Element() AddElement(Element()) Element()\elementvariable = 100
Wir legen zuerst mit dem Befehl "Structure" einen begrenzten Array an, der die Variable elementvariable.l enthält (die Variable ist im long Zahlenformat abgespeichert). Mit Endstructure weisen wir darauf hin, dass ab jetzt die Deklaration des Elementes "Element" abgeschlossen ist. Mit Newlist erzeugen wir eine Linked List (so was wie eine dynamische Liste der in "Element" deklarierten Variablen) namens Element() aus dem structure-Element, sodass wir die Liste dynamisch ändern können. Mit AddElement fügen wir zu der Liste "Element" ein Element hinzu. Mit Element()\elementvariable = 100 weisen wir der Variable elementvariable im gerade erzeugten Element den Wert 100 zu.
[Bearbeiten] Referenzen
Befehlsübersicht
Tipps 'n' Tricks
[Bearbeiten] Weblinks
[5] Zur Purebasic Hauptseite
[6] Zum Purebasic Forum
[7] PureBasic Ressourcen, Codes, Hilfe & vieles mehr
[8] Zum alternativen Purebasic Forum
[9] deutschsprachige Dokumentation
[10] umfangreiches, kostenloses PureBasic Handbuch
[11] API-Hilfedatei die in die PureBasic Hilfe eingebunden werden kann (auch kostenlos)
[12] Diese Seite bietet viele kostenlose Tutorials zu PureBasic an
[13] Viele nützliche Codes und Tools
