Inhaltsverzeichnis

std.strtype

String ist eine besitzende, längentragende Zeichenkette — die Antwort auf die drei Schwächen von pchar: Ein pchar ist ein roher, NUL-terminierter C-String, dessen Länge bei jeder Abfrage neu gesucht werden muss, der kein NUL-Byte enthalten darf und dem man nicht ansieht, wem der Speicher gehört.

String trägt seine Bytelänge und Kapazität explizit mit, erlaubt eingebettete NUL-Bytes und besitzt seinen Puffer. Die Unit kommt ohne libc aus: Der Speicher stammt ausschließlich aus mmap/munmap.

String arbeitet auf Bytes. Wer Zeichen im Sinne von Unicode-Codepoints zählen oder schneiden will, nimmt std.text.

Autor: Andreas Röne
Copyright: 2024-2026 Andreas Röne

→ std.text · std.string (pchar-Ebene) · Standard Library

Erzeugen und freigeben

String ist eine Klasse mit Referenzsemantik. Erzeugt wird über eine der drei freien Funktionen — oder über new String() plus eine Init-Methode. 

import std.io;
import std.strtype;

fn main(): int64 {
    var a: String := StringFromPchar("Hallo"c);
    var b: String := StringFromPchar(", Welt"c);

    var c: String := a.Add(b);              // neue Zeichenkette, a und b bleiben
    PrintLn(IntToStr(c.Length()));          // 11

    var p: pchar := c.ToPchar() as pchar;   // frische NUL-terminierte Kopie
    PrintLn(p);                             // "Hallo, Welt"

    a.Free(); b.Free(); c.Free();
    return 0;
}

Funktion Beschreibung
StringNew(cap: int64): String Leere Zeichenkette mit vorreservierter Kapazität
StringFromPchar(p: int64): String Kopiert einen NUL-terminierten pchar
StringFromBytes(ptr: int64, n: int64): String Kopiert n rohe Bytes — NUL-Bytes eingeschlossen

Free() gibt den Puffer per munmap frei und setzt das Objekt auf leer zurück. Es gibt kein automatisches RAII — jede erzeugte String braucht ihr Free(), auch die aus Add und Substring entstandenen Zwischenergebnisse.

 
ToPchar() gibt eine neue Allokation zurück, keinen Blick in den Puffer. Die Kopie ist Length()+1 Bytes groß und gehört dem Aufrufer; sie überlebt ein Free() der Quelle. Der Rückgabetyp ist int64 — für PrintLn erst in eine pchar-Variable schreiben (var p: pchar := s.ToPchar() as pchar;), ein as pchar direkt im Argument wird nicht übernommen.

Methoden

Signatur Beschreibung
InitCap(cap: int64) Puffer mit Kapazität cap anlegen (nach new String())
InitFromBytes(ptr: int64, n: int64) Aus n rohen Bytes initialisieren
InitFromPchar(p: int64) Aus pchar initialisieren
Length(): int64 Bytelänge — ohne NUL-Suche, O(1)
CharAt(i: int64): int64 Byte an Position i; 0 außerhalb der Grenzen
Data(): int64 Zeiger auf die Rohbytes — gültig für Length() Bytes, nicht NUL-terminiert
Reserve(need: int64): int64 Platz für need weitere Bytes sichern; verdoppelt die Kapazität. 1 = ok, 0 = kein Speicher
AppendChar(c: int64): int64 Ein Byte anhängen
AppendBytes(ptr: int64, n: int64): int64 n rohe Bytes anhängen
AppendPchar(p: int64): int64 pchar anhängen
Append(other: String): int64 Andere String anhängen (verändert self)
Add(other: String): String Neue Zeichenkette aus self ++ other
Substring(start: int64, count: int64): String Neue Zeichenkette aus dem Byte-Bereich; Grenzen werden zurechtgestutzt
Equals(other: String): int64 Inhaltsvergleich, 1/0
EqualsPchar(p: int64): int64 Inhaltsvergleich gegen pchar
Compare(other: String): int64 Lexikografischer Bytevergleich: -1, 0, 1
ToPchar(): int64 Frische NUL-terminierte Kopie; 0 bei Speichermangel
Free() Puffer freigeben

Anhängen verändert, Ableiten kopiert

Die Unterscheidung ist wichtig für die Freigabe: Append* schreibt in die vorhandene Zeichenkette (der Puffer wächst bei Bedarf), Add und Substring liefern ein neues Objekt, das eigens freigegeben werden muss. 

var s: String := StringNew(16);
s.AppendPchar("Zeile "c);
s.AppendChar(49);            // '1'
PrintLn(IntToStr(s.Length()));   // 7
s.Free();

Operatoren

String trägt die Methodennamen, nach denen die Operator-Überladung sucht (→ OOP, Abschnitt 8). Damit arbeiten die Operatoren inhaltsbasiert statt auf Adressen:

Operator Methode Ergebnis
a + b Add neue String
a == b Eq Inhaltsgleichheit
a != b Ne
a < b, a ⇐ b, a > b, a >= b Lt/Le/Gt/Ge abgeleitet aus Compare
a[i] Get Byte an Position i

Letzte Aktualisierung: 2026-08-11