====== 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 ''[[lyx_-_programmiersprache:units:text|std.text]]''.

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

→ [[lyx_-_programmiersprache:units:text|std.text]] · [[lyx_-_programmiersprache:units:string|std.string]] (''pchar''-Ebene) · [[lyx_-_programmiersprache:units|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.

<code lyx>
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;
}
</code>

^ 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.

<box gh>
> **''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.
</box>

----

===== 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.

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

----

===== Operatoren =====

''String'' trägt die Methodennamen, nach denen die Operator-Überladung sucht (→ [[lyx_-_programmiersprache:sprache:oop|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