Strings in C

Strings in C

Strings in der Programmiersprache C sind Zeichenketten, die als Arrays von `char` repräsentiert werden und immer durch ein spezielles Nullterminierungszeichen (`'\0'`) abgeschlossen werden. Da C im Gegensatz zu höheren Programmiersprachen keinen eigenen String-Datentyp bereitstellt, müssen Speicherverwaltung und Länge von Strings explizit beachtet werden.

Darstellung von Strings

Ein String ist ein Array von Zeichen:

char text[] = "Hallo";

Intern sieht das so aus:

'H' 'a' 'l' 'l' 'o' '\0'

Die Nullterminierung (`\0`) markiert das Ende des Strings und ist entscheidend für viele Bibliotheksfunktionen (z. B. `strlen`, `printf`, `strcmp`).

Wichtige Standardfunktionen für Strings

Die Header-Datei `string.h` stellt grundlegende Funktionen bereit:

Funktion	Beschreibung
`strlen(s)`	Gibt die Länge eines Strings (ohne `\0`) zurück.
`strcpy(dest, src)`	Kopiert einen String (ohne Längenprüfung!).
`strncpy(dest, src, n)`	Kopiert höchstens n Zeichen.
`strcmp(s1, s2)`	Vergleicht zwei Strings lexikographisch.
`strcat(dest, src)`	Hängt einen String an einen anderen an.

Ausgabe von Strings mit printf

Die Funktion `printf` (aus `stdio.h`) dient zur Ausgabe formatierter Daten auf der Konsole.

Beispiel

#include <stdio.h>

int main() {
    char name[] = "Alice";
    printf("Hallo %s!\n", name);
    return 0;
}

Das Formatierungssymbol `%s` steht für Strings.

Erstellen formatierter Strings: sprintf und snprintf

sprintf

`sprintf` schreibt einen formatierten String in einen Puffer.

char buffer[50];
sprintf(buffer, "Ergebnis: %d", 42);

Wichtig: `sprintf` führt **keine** Längenprüfung durch → Gefahr von **Buffer Overflows**.

snprintf

`snprintf` ist die sichere Variante und begrenzt die Anzahl der geschriebenen Zeichen.

char buffer[50];
snprintf(buffer, sizeof(buffer), "Ergebnis: %d", 42);

Der String wird automatisch mit `\0` abgeschlossen, solange die Puffergröße > 0 ist.

Vergleich

Funktion	Längenprüfung	Risiko
`printf`	Ausgabe auf Konsole	gering
`sprintf`	keine	hoch (Buffer Overflow)
`snprintf`	ja	deutlich reduziert

Sichere String-Behandlung

Da C keine automatische Speicherüberwachung bietet, sind folgende Regeln wichtig:

• Immer Puffergrößen kennen.
• `snprintf` statt `sprintf` verwenden.
• Nie ungeprüfte Benutzereingaben direkt kopieren.
• Bei dynamischer Allokation an `free()` denken.

Beispielprogramm

#include <stdio.h>
#include <string.h>

int main() {
    char name[] = "Alice";
    char msg[100];

    snprintf(msg, sizeof(msg), "Hallo %s, willkommen!", name);
    printf("%s\n", msg);

    return 0;
}

Boost.Format (C++)

Während C keine komfortablen Formatierungsmechanismen über `printf` hinaus bietet, stellt die C++-Bibliothek Boost.Format ein flexibles Formatierungssystem bereit, das typsicher und ausdrucksstark ist.

Boost.Format verwendet ein Format ähnlich zu `printf`, aber in **C++-typischer Syntax**:

#include <boost/format.hpp>
#include <iostream>

int main() {
    std::string name = "Alice";
    int score = 42;

    std::cout << boost::format("Name: %1%, Punkte: %2%") % name % score << std::endl;
}

Vorteile gegenüber printf

• Typprüfung zur Compile-Zeit (vermeidet Formatierungsfehler)
• Beliebige Datentypen formattierbar (auch Klassen)
• Lesbarer und wartbarer Code

Nachteile

• Boost ist eine zusätzliche Abhängigkeit
• Geringere Performance als `printf` oder `snprintf` in sehr zeitkritischen Bereichen

Zusammenfassung

• In C sind Strings nullterminierte `char`-Arrays.
• `printf`, `sprintf` und `snprintf` ermöglichen formatierte Ausgabe bzw. Stringgenerierung.
• Für sichere Stringmanipulation sollte **immer `snprintf` gegenüber `sprintf` bevorzugt werden**.
• In C++ bietet `Boost.Format` eine moderne, typsichere Alternative zur Formatierung.

Siehe auch

• C Standardbibliothek
• Memory Management in C
• Sicherheitslücken: Buffer Overflow
• Format String Attacks

Weblinks

• https://en.cppreference.com/w/c/string
• https://en.cppreference.com/w/c/io/fprintf
• https://www.boost.org/doc/libs/