Kapitel 7: Arrays & Mappings

7.1 Warum brauchen wir Arrays und Mappings?

Bisher hast du hauptsächlich mit einzelnen Variablen gearbeitet: eine Zahl, ein String, ein Objekt. In echten Programmen reicht das fast nie aus.

Typische Fragen sind:

• Wie speichere ich mehrere Gegenstände?
• Wie merke ich mir viele Spieler?
• Wie ordne ich Namen bestimmten Werten zu?

Genau dafür gibt es Arrays und Mappings.

7.2 Arrays – geordnete Listen von Werten

Ein Array ist eine geordnete Liste von Elementen. Jedes Element hat eine Position (Index), beginnend bei 0.

int *numbers;

numbers = ({ 10, 20, 30 });
      

Dieses Array enthält drei Zahlen:

• numbers[0] → 10
• numbers[1] → 20
• numbers[2] → 30

7.3 Arrays auslesen

Auf einzelne Elemente greifst du mit eckigen Klammern zu.

write(numbers[1] + "\n");  // gibt 20 aus
      

Wichtig: Greife niemals außerhalb der Array-Grenzen zu.

// Fehler!
write(numbers[10]);
      

7.4 Größe eines Arrays

Mit sizeof() bekommst du die Anzahl der Elemente.

int size;

size = sizeof(numbers);  // 3
      

Sehr wichtig für Schleifen!

7.5 Über Arrays iterieren

Meist willst du alle Elemente eines Arrays verarbeiten.

int i;

for (i = 0; i < sizeof(numbers); i++)
{
  write(numbers[i] + "\n");
}
      

Alternativ (und moderner):

int n;

foreach (n : numbers)
{
  write(n + "\n");
}
      

7.6 Arrays verändern

Arrays sind in LPC dynamisch – du kannst sie verändern.

numbers += ({ 40 });
numbers -= ({ 20 });
      

Ergebnis:

({ 10, 30, 40 })
      

7.7 Typische Array-Typen im Midgard MUD

string *names;
object *inv;
mixed *data;
      

mixed-Arrays können alles enthalten – sind aber schwieriger zu debuggen.

7.8 Mappings – Schlüssel-Wert-Paare

Ein Mapping ist vergleichbar mit einem Wörterbuch: Ein Schlüssel verweist auf einen Wert.

mapping stats;

stats = ([
  "str" : 10,
  "dex" : 12,
  "int" : 15
]);
      

Hier ordnest du Namen konkrete Werte zu.

7.9 Werte aus Mappings lesen

int strength;

strength = stats["str"];
      

Existiert der Schlüssel nicht, bekommst du 0.

write(stats["foo"]); // 0
      

7.10 Werte in Mappings setzen und ändern

stats["str"] = 20;
stats["wis"] = 8;
      

Mappings wachsen automatisch.

7.11 Über Mappings iterieren

Du kannst Schlüssel und Werte getrennt auslesen.

string key;

foreach (key : m_indices(stats))
{
  write(key + ": " + stats[key] + "\n");
}
      

Alternativ:

string k;
int v;

foreach (k, v : stats)
{
  write(k + ": " + v + "\n");
}
      

7.12 Arrays vs. Mappings – wann was?

• Array → Reihenfolge wichtig
• Array → Zugriff über Zahlen
• Mapping → Zuordnung wichtig
• Mapping → Zugriff über Namen

Beispiel:

// Inventar → Array
object *inv = all_inventory(this_player());

// Attribute → Mapping
mapping attrs = this_player()->QueryProp(P_ATTRIBUTES);
      

7.13 Häufige Anfängerfehler

• Array-Grenzen überschreiten
• sizeof() vergessen
• Mapping-Schlüssel verwechseln
• mixed zu oft verwenden

7.14 Mini-Übungen

1. Erstelle ein Array mit fünf Zahlen und gib sie aus.
2. Erstelle ein Mapping für Spielerattribute.
3. Iteriere über ein Mapping und gib alle Paare aus.

7.15 Zusammenfassung

• Arrays speichern geordnete Daten
• Mappings speichern Zuordnungen
• foreach vereinfacht Iterationen
• Beide Datentypen sind essenziell

Mit Arrays und Mappings kannst du nun echte Datenstrukturen bauen.

Ausblick

In Kapitel 8 geht es um Objekte, Vererbung und das Objektmodell des Midgard MUDs – das Herzstück von LPC.