Datentypen ( Pawn )

Hallo Liebe Community,

heute möchte ich verdeutlichen wozu die Datentypen in Pawn eigentlich da sind & warum man sie so benutzt.

Dieses Element wird genutzt wenn die Funktion erst in den Ausgabecode aufgenommen werden soll sobald sie aufgerufen wird sprich vorher wird
sie nicht überprüft oder sonstiges selbst mit Fehlern wird sie ignoriert da sie in die Ausgabe nicht einbezogen wird.

• Datentypen ( String, Integer, Boolean ) können wiedergegeben werden

Dieses Element stellt eine öffentliche Variable/Funktion dar, Öffentlich heißt nicht nur um gesamten Code Bereich den ihr im Moment vor euch habt,
sondern es heißt auch das das diese Variablen/Funktionen nicht nur Intern als vom Skript aufrufbar sind sondern auch an Externen Schnittpunkten aufgerufen werden
können.

• Können keine Standardwerte in Parametern übernehmen
• Können nur Integer wiedergeben

Statische Variablen, diese Art von Variablen/Funktionen werden nicht nur definiert weil es schön aussieht, nein sie werden definiert da sie immer ihren Speicherplatz behalten sprich
sie bleiben im Speicher immer an der selben stelle, diesen behält diese Variable/Funktion solange bis sie letztendlich vom Code selber zerstört wird sprich
solange bis der Lokale Bereich für die Variable seine Gültigkeit behält.

Nicht sehr besonders, definiert im Grund eine Variable auf Lokaler Bereichsbasis, sollte jeder kennen.

Float oder auch Floating Point Value zu Deutsch eine Komma Zahl, dieser Datentyp kann nicht nur gerade Zahlenwerte Speichern sondern
auch Werte die aus dem Koordinatenbereich stammen sprich Große & genaue Werte wenn man das so ausdrücken darf.

Konstante Variablen sprich wie das Wort selber schon sagt, sie sind fest & können nicht verändert werden, diese können z.b. als
Index Angabe verwendet werden da sicher ist das der festlege Speicher bleibt & somit nichts verrutschen kann,
zu den Konstanten Variablen zählen mitunter auch die Makro Variablen die im Grund durch den Compiler nur ersetzt werden,
sprich sie werden nicht als Bezeichner übernommen der auf eine Adresse zeigt sondern der Wert in ihnen wird Direkt
im Speicher zugeteilt.

Wozu die ganzen Datentypen ?

Das hat sich bestimmt jeder mal gefragt, jedoch muss man bedenken das
durch Datentypen genaue Reservierungen im Speicher entstehen, genauer
gesagt es wird nur soviel Platz reserviert wie benötigt wird.
Würde der Compiler das nicht tun müsste er ungenau festlegen was er brauche sprich
einen Maximalen Wert haben der ihm sagt so viel könnte der Nutzer brauchen
das würde die Ausgabe umso größer machen & wenn man das dann auf mehrere Werte
verteilt wäre dies das Chaos pur besonders, für Systeme die nicht die optimale Leistung
erbringen könnten wäre wäre diese Ausgabe der reinste Selbstmord sprich
sie könnten diesen Speicher nicht aufbringen oder die Anweisungen wären einfach
zu lang & würden Zeit kosten.

Warum stürzt manchmal der Compiler ab ?

Das hat damit zu tun das es stellen gibt die die Analyse nicht erkennt jedoch trotzdem
in den Speicher verschiebt so kann es dazu kommen das der Temporäre Compiler Speicher
eine Falsche Anweisung bekommt die nicht verarbeitet werden kann, so stürzt der Prozess ab.

Was können Funktionen wann wiedergeben ?

Manchmal gibt es Probleme bei der Wiedergabe aber dann nur wenn
eine Funktion sprich die Sprache diesen Datentypen nicht Automatisch
erkennt & seine Struktur nicht übernehmen kann,
dann müssen Funktionen mit einem Tag belegt werden sprich einer
Eigenschaft die der Funktion sagt welche Struktur bei der Wiedergabe
übernommen werden soll.

( Float ) :

//Variablen
const Float:value = 3.14;
new Float:value = 3.14;

// Beispiel Funktion
Float:Funktion( param0 , param1 )return 7.1;

// Nur anders...
forward Float:Funktion( Float:param0 , Float:param1 ); // Deklarieren
Float:Funktion( Float:param0 , Float:param1 )
{
return (param0+param1);
}

( Array/Zeichenfolgen ) :

Im Grunde nur viele normale Variable die
viele Zeichen zusammensetzen.

new text[32]; // 32 Zeichen von 0 angefangen 0..31

// verwendung 2
new text[] = {'H','A','L','L','O'}; // Größe wird Automatisch übernommen
new text[] = {1,2,3,4}; // Auch Zahlen sind Möglich...
new text[] = "Hallo"; // Geht auch...
new text[]; // << FALSCH, warum ? Keine Größe kein reservierter Speicher = keine spezielle Größe .
new einZeichen = 'A'; // Geht auch
new einZeichen = 2; // Zahl 2

// Anwendungen...

new text[] = "Hallo Welt";
printf("%s",text); // << Gibt den Text Hallo Welt wieder

// Anwendung 2
printf(text); // << Printf erwartet sowieso eine Array ... daher geht das ebenso Direkt...
print(text); // genau das gleich nur das Print keinen f(ormat) enthält

// Spezielle Anwendungen...

printf(text[3]); // Nein nicht nur die Stelle 3 wird wiedergegeben sondern alles ab Stelle 3
/* Dabei kommt lo Welt raus */

new einmal = 2;
printf(einmal); // << Falsch , es wird eine Array erwartet keine Variable mit nur einer Zelle
printf("%i",einmal); // << Geht %i = Integer als Platzhalter , printf fügt dies nun in den Text ein.

new einzeichen = 'a';
printf("%c",einzeichen); // << %c = Char = Zeichen

// Weitere Anwendung...
new testtext[] = "Test";
new laenge = strlen(Test);

// Wenn man die Länge ab Stelle 2 haben will
laenge = strlen(Test[2]); // << da eine Array erwartet wird, wird alles mitgenommen hinter Stelle 2, dazu muss die Variable auch ein Array sein

(Eigene Struktur) :

enum struktur // Neue Struktur
{
wert1,
wert2
}

forward struktur:testfunktion(struktur:test); // Deklarieren
struktur:testfunktion(struktur:test) // Funktion hat die Struktur ,,struktur´´
{
test = struktur:(12,5);//Wert1 = 12, Wert2 = 5
return test; // Struktur wiedergeben
}

( Enum richtig verwenden ) :

enum test_struktur
{
Float:kommazahl,
integer,
string[32]
}

Strukturen sind dazu da um Datentypen kompakt in eine Variable einzubinden sprich Strukturen innerhalb
einer Variable zu erschaffen.

Beispiel
new variable[test_struktur];

Zugriff
variable[integer] = 5;
printf("Integer Value : %d",variable[integer]);

Genau das gleich bei allen anderen Variable, die je nach dem den bestimmten & eingetragenen Datentyp
beinhalten & erfordern.

Mehrere Zugriffe sprich mehrmals mehrere Werte Dynamisch verändern.

new variable[50][test_struktur]; // 50x die test_struktur also kann man an jeder Stelle neue Werte eintragen.

Im großen und ganzen schafft ihr mit diesem System ein gewisse Ordnung, selbst einzelne Variablen wie hier

enum vars
{
server_verbindungen,
server_getrennt
}
new Server[vars];

Server[server_verbindungen]++;
Server[server_getrennt]++;

So das war es soweit, ich hoffe ich konnte euch hiermit helfen sprich ein Schritt weiter an die Basis heranführen.

@ ist eine Alternative zu Öffentlichen Funktionen sprich eine Möglichkeit.

Das ist das Ziel dabei, nicht nur gucken & nicht nach Vorlage zu arbeiten sondern das Wissen muss
von einem selber kommen.

Wird bei bedarf verbessert.

~ Danke für das bisherige Feedback ~

Danke

So hab mal mit Code Beispielen weitergemacht, habe versucht jede Möglichkeit in Betracht zu ziehen,
sind ganz unten im Hauptthema zu finden sprich der letzte Punkt.