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)
- Integrierte 3D Engine
- Lesen und Speichern von Daten
- Direkte Nutzung von Windows-API (nur Windows), SDL und GTK (nur Linux) Befehlen
- Verarbeitung von XML Dokumenten
Zusätzlich hat Purebasic eine (ältere) 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 kann PureBasic Quelltexte auf folgenden Systemen (ohne sie dem System anpassen zu müssen) kompilieren: Windows 32-Bit, Windows 64-Bit, Linux 32-Bit, Linux 64-Bit, AmigaOS und Mac OS X (Intel und Power Pc).
[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 Konsolen-Progamme und Dynamic Link Libraries (*.dll Dateien)[1] zu erstellen. Zudem gibt es auch Versionen für Linux[2] (Shared Objects, *.so Dateien), MacOS[3] und AmigaOS[4].
[Bearbeiten] Grundlagen
[Bearbeiten] Allgemeine Grundlagen
Ein paar ganz wichtige Syntaxregeln sind zu beachten:
PureBasic arbeitet zeilenorientiert, 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 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.
Befehle werden gefolgt von einer öffnenden Klammer, den Parametern (getrennt durch Kommas) und einer schließenden Klammer aufgerufen. Beispiel:
OpenConsole() ; Der Befehl OpenConsole hat keine Parameter.
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] Praxiseinschub: Ein einfaches HelloWorld-Programm
Code:
OpenConsole() ; Dieser Befehl öffnet eine Konsole
Print("Hallo Welt") ; in der dann "Hallo Welt" ausgegeben wird.
Delay(5000) ; Hält den Programmablauf für fünf Sekunden(5000 Millisekunden) an.
Die Anführungzeichen um das Hallo Welt zeigen dem Compiler, dass es sich um einen Text handelt. Die Zeile "Delay(5000)" ist nötig, weil ansonsten das Programm vorbei wäre, bevor man überhaupt sehen könnte, was ausgegeben wurde.
[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 |
| integer | .i | 4 Byte (32 Bit) | -2147483648 - +2147483647 |
| integer | .i | 8 Byte (64 Bit) | -9223372036854775808 - +9223372036854775807 |
| 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!
Bei dem Variablentyp Integer ist zu beachten, dass er je nach Architektur des Systems (32 Bit oder 64 Bit) einen unterschiedlichen Zahlenbereich besitzt. Seit PureBasic 4.30 ist Integer der Standard Variablentyp (wenn man diesen benutzen möchte, muss man das ".i" nicht an das Ende des Variablennamen anhängen).
[Bearbeiten] Explizite Definition von Variablen
Für mehr Übersichtlichkeit, oder um die Gültigkeit der Variablen besser festlegen zu können, kann man Variablen auch explizit definieren. Das heißt, dass alle Variablen vor ihrer Benutzung erst ein mal deklariert werden müssen, da das Programm ansonsten nicht kompiliert wird. Beispiele:
Define a.s
Ist das gleiche wie
a.s=""
Oder
Define.s a
Mehrere Variablen können auch auf einmal definiert werden. Zum Beispiel:
Define a.s,b.l,c.f
Oder
Define.s x,y,z
Damit Tippfehler bei Variablen nicht zu Fehlerquellen werden können, gibt es die Schlüsselwörter "EnableExplicit" und "DisableExplicit". Es ist zwar auch möglich, außerhalb von "EnableExplicit" Variablen explizit zu definieren, allerdings ist das zwischen Enable- und DisableExplicit die einzige Möglichkeit. Dieser Code würde also nicht mehr funktionieren:
EnableExplicit a.s="Das geht nicht" DisableExplicit
Es gibt auch andere Schlüsselwörter zum expliziten Definieren von Variablen; allerdings sind diese ohne Vorwissen für das Erstellen von Funktionen irrelevant, weshalb ich sie im entsprechenden Kapitel "Funktionen" auflisten werde.
[Bearbeiten] Operatoren
In Purebasic gibt es folgende Numerische Operatoren (also sozusagen Rechenzeichen):
| Name | Zeichen | Beschreibung |
|---|---|---|
| Plus | + | Addition |
| Minus | - | Subtraktion |
| Mal | * | Multiplikation |
| Geteilt | / | Division |
| Bitweise Operatoren | Operatoren, die auf jedes Bit einzeln angewendet werden. | |
| Bitweises "und" | & | Verknüpft zwei Zahlen. Nur jedes Bit, das bei beiden Zahlen gesetzt ist, wird auch beim Ergebnis gesetzt sein.
Beispiel: Die Zahl 5 ist Binär 101, Die Zahl 6 110. Deswegen ergibt 5&6 in Binär 100, weil nur das Bit mit dem Wert 4 bei beiden Zehlen gesetzt ist. 5&6=4 |
| Bitweises "oder" | | | Ein Bit, das bei mindestens einer der Zahlen gesetzt ist, wird auch beim Ergebnis gesetzt sein.
Beispiel: Binär 101|110=111 Dezimal 5&6=7 |
| Bitweises "ausschließendes oder" | ! | Ein Bit, das bei genau einer Zahl gesetzt ist, wird auch beim Ergebnis gesetzt sein.
Beispiel: Binär 101|110=011 Dezimal 5!6=3 |
| Bitweises "nicht" | ~ | Dieser Operator arbeitet nur mit einem Wert. Ist ein Bit beim Eingabewert gesetzt, dann wird es beim Ergebnis nicht gesetzt sein, ist es nicht gesetzt, dann wird es gesetzt sein.
Beispiel: Binär ~101=010 Dezimal ~5=2 |
| Klammern | () | Eingeklammertes wird zuerst gerechnet |
| Vergleichsoperatoren | Operatoren, die zwei Werte vergleichen und einen Bool, also eine 1 (#True) für wahr oder eine 0 (#False), wenn die Bedingung nicht erfüllt wird, zurückgeben. | |
| gleich | = | Sind die Werte gleich? |
| größer als | > | Ist der linke Wert größer? |
| kleiner als | < | Ist der linke Wert kleiner? |
| größer als oder gleich | >= | Ist der linke Wert größer oder gleich? |
| kleiner als oder gleich | <= | Ist der linke Wert kleiner oder gleich? |
| ungleich | <> | Sind die Werte ungleich? |
| logische Operatoren | Logische Operatoren werden auf Warheitswerte angewendet und geben zurück ob diese im entsprechenden verhältnis stehen. | |
| logisches "und" | AND | Sind beide Werte (Wahr)?
Beispiel: a=1 b=17 a AND b ;wird wahr(1) zurückgeben |
| logisches "oder" | Or | Ist einer der Werte (Wahr)? |
| logisches "ausschliessendes oder" | XOr | Ist einer der Werte, aber nicht beide (Wahr)? |
| logisches "nicht" | Not | Kehrt die Wahrheit um (was wahr war wird falsch sein).
Anders ausgedrückt: Ist der Wert unwahr? |
Um zum Beispiel die Variable a um 10 zu erhöhen kann man schreiben
a=a+10
oder aber auch
a=10+a
oder einfach
a+10
Zum Verknüpfen von Strings kann + auch als Zeichenkettenoperator verwendet werden. Beispiel:
a.s="PureBasic" Debug "Das ist " + a
Das wird "Das ist PureBasic" zurückgeben. Die Leerzeichen vor, und nach den Operatoren sind freiwillig und dienen nur zur Besseren Übersicht.
[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.
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.
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. Falls man bestimmte Variablen in allen Funktionen verfügbar machen möchte, muss man sie mithilfe des Schüsselworts "global" Definieren (Siehe Explizite Definition von Variablen). Beispiel:
Global a.l=17 Define b.l=185 Procedure Test() Debug a Debug b EndProcedure
Die Ausgaben werden 17 und 0 sein weil die Variable b nur im Hauptcode 185 enthält und nicht, wie Variable a im Gesamten Code gleichermaßen verfügbar ist.
Um Variablen ausdrücklich NUR in einer Funktion zur Verfügung zu haben muss sie dort mit "protected" definiert sein. Dann wird nicht die Variable des Hauptcode verwendet auch wenn diese a global definiert wurde.
Global a.l=17 Global b.l=185 Procedure Test() Protected a Debug a Debug b EndProcedure
Hier werden die Ausgaben 0 und 185 sein.
Um in einer Funktion auf nicht global definierte Variablen des Hauptcodes zuzugreifen kann man das Schlüsselwort shared verwenden. Beispiel:
Define a.l=17 Define b.l=185 Procedure Test() schared b Debug a Debug b EndProcedure
Die Ausgabe wird 0 und 185 sein.
[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 "zeigt" auf eine Speicheradresse.
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 der Pointer pointer den die Speicheradresse von a mittels dem "@"-Zeichen (Referenz-Operator) übertragen. Das "*" am Anfang der Variable pointer gehört fest zum Identifier. Es zeichnet ihn als Pointer aus und ist nicht optional.
[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:
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.
Wir erzeugen nun ein dynamisches Array und greifen darauf zu:
(Code by M.E., maikeck(_at_)web.de)
Structure test sizeB.l *zahlen.l EndStructure erste.test erste\sizeB = 10 * SizeOf(Long) erste\zahlen = ReAllocateMemory(erste\zahlen, erste\sizeB) zahl.l = 0 For i = 0 To erste\sizeB - SizeOf(Long) Step SizeOf(Long) *pointer = erste\zahlen + i PokeL(*pointer, zahl) zahl = zahl + 1 Next ;Testausgabe: For i=0 To erste\sizeB - SizeOf(Long) Step SizeOf(Long) *pointer = erste\zahlen + i Debug "zahl: "+Str(PeekL(*pointer)) Next
;dynamisch macht es erst das:
Procedure addToArray(val.l) Shared erste oldsize = erste\sizeB erste\sizeB = erste\sizeB + SizeOf(Long) erste\zahlen = ReAllocateMemory(erste\zahlen, erste\sizeB) *pointer = erste\zahlen + oldsize PokeL(*pointer, val) EndProcedure ;Aufruf: addToArray(99) ;erneute Testausgabe: For i=0 To erste\sizeB - SizeOf(Long) Step SizeOf(Long) *pointer = erste\zahlen + i Debug "zahl: "+Str(PeekL(*pointer)) Next
[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.
Strings zeichenweise auslesen (Code by M.E., maikeck(_at_)web.de):
string$ = "Teststring" For i = 0 To Len(string$) - 1 char$ = PeekS(@string$+i,1) Debug char$ Next ;man kann das auch so auslesen: For i = 0 To Len(string$) - 1 char.c = PeekC(@string$+i) Debug Chr(char) Next
[Bearbeiten] Linked Lists
Linked Lists[5] sind, ähnlich den Arrays, Listen um mehrere Elemente des gleichen Datentyps zu verwalten. Allerdings wird, im Gegensatz zu den Arrays, die Größe der Linked Lists von Purebasic dynamisch verwaltet und je nach Bedarf automatisch angepasst.
Hier eine kleine Demonstration:
Code:
NewList List.l() For i = 1 To 10 AddElement(List()) List() = i Next ForEach List() Debug List() Next
Zuerst wird mit NewList eine neue Liste List von Longs erstellt. In der For-Next Schleife werden dann nacheinander 10 neue Elemente in die Liste hinzugefügt und mit der aktuellen Zählvariable initialisiert. Im nächsten Codeabschnitt werden mit Foreach alle in der Linked List enthaltenen Elemente mit Debug wieder ausgegeben.
Man kann jeden beliebigen Variablentyp für die Liste benutzen. Ebenso selbst definierte Strukturen.
[Bearbeiten] Referenzen
Befehlsübersicht
Tipps 'n' Tricks
[Bearbeiten] Weblinks
[6] Zur Purebasic Hauptseite
[7] Zum Purebasic Forum
[8] PureBasic Ressourcen, Codes, Hilfe & vieles mehr
[9] Zum alternativen Purebasic Forum
[10] Online eBook für PureBasic-Einsteiger
[11] deutschsprachige Dokumentation
[12] umfangreiches, kostenloses PureBasic Handbuch
[13] API-Hilfedatei die in die PureBasic Hilfe eingebunden werden kann (auch kostenlos)
[14] Diese Seite bietet viele kostenlose Tutorials zu PureBasic an
