Zeichenketten: String

Die von C geerbten Zeichenketten haben den großen Nachteil, dass der Speicher nicht dynamisch nach Anforderung belegt wird, sondern dass immer so viel Speicher blockiert wird, wie im schlechtesten Fall erforderlich ist. Auch das Fehlerpotenzial, das durch das Fehlen der Abschluss-Null und der fehlenden Kontrolle der Speichergrenzen entsteht, hat viele Programmierer veranlasst, eine eigene Stringklasse zu schreiben. Inzwischen ist aber eine Klasse string in der Standardbibliothek verfügbar.

Verwendung

#include <string>
using namespace std;

string meinName;

Kompatibilität

Unterschiede

Vorteile

Zuweisung

Verbinden

#include <string>
using namespace std;

string meinName = "neu";
char oldName[25] = ält";
string neuString;


    neuString = meinName;            // "neu"
    neuString = oldName;             // ält"
    neuString = meinName + oldName;  // "neualt"
    neuString += oldName;            // "neualtalt"

Vergleiche

string s;
char cstring[256];
    ...
    if (s < cstring)
    ...
    if (cstring < s)

Elementfunktionen

[String-Funktionen]

Funktion	Aufgabe
length()	liefert die Länge des Strings
insert(n, s)	fügt den String s an Position n ein
erase(p, n)	Entfernt ab Position p n Zeichen
find(s)	Liefert die Position, an der sich der String s befindet

Beispiel

#include <string>
using namespace std;

int main()
{
    string s("123");    // Konstruktor fuer C-String
    len = s.length();   // liefert 3, die Laenge des Strings
    s.insert(2, "xy");  // s ist nun "12xy3"
    s.erase(2,2);       // s ist nun "123"
    pos = s.find("23"); // liefert die Position 1
}

Zugriff über Zeiger

Speicheradresse

Iterator

Beispiel

[Auslesen eines Strings über einen Iterator (stringit.cpp)]

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string s = "Testlauf";
    string::iterator i;
    for (i=s.begin(); i!=s.end(); i++)
    {
        cout << *i ;
    }
    cout << endl;
}

Gültigkeit

Revers

[Rückwärtslaufen über Iterator (stringrev.cpp)]

#include <iostream>
#include <string>
using namespace std;

int main()
{
    string s = "Testlauf";
    string::reverse_iterator i;
    for (i=s.rbegin(); i!=s.rend(); i++)
    {
        cout << *i ;
    }
    cout << endl;
}

Umwandlung zwischen Zahlen und Zeichenketten

#include <sstream>
using namespace std;

int meineZahl;
string s("123");
istringstream inStream(s);
inStream >> meineZahl;

#include <sstream>
using namespace std;

int meineZahl = 976;
string s;
ostringstream outStream;
outStream << meineZahl;
s = outStream.str();

Um die Stringvariable Ihren Ausgabebedürfnissen anzupassen, können Sie auch Manipulatoren verwenden.

Ältere Versionen von C++ bieten mit strstream eine Klasse mit ähnlicher Funktionalität. Allerdings empfiehlt der Standard ausdrücklich, diese Klasse strstream nicht mehr zu verwenden. (vgl.: Kaiser, Richard: C++ mit dem Borland C++ Builder. Springer, Berlin-Heidelberg. 2002. S. 375.)

Andere String-Bibliotheken

Klassische C-Funktionen

while(*Quelle)
{
    *Ziel++ = *Quelle++;
}
*Ziel = 0;

char *Quelle;
char Ziel[MAX];
   ...
   strncpy(Ziel, Quelle, MAX);
   Ziel[MAX-1] = 0; // stört nie, ist aber sicherer

char *Quelle;
char Ziel[MAX];
...
strncat(Ziel, Quelle, MAX-strlen(Ziel));
Ziel[MAX-1] = 0; // stört nie, ist aber sicherer

#include <string.h>

char *strcat(char *Ziel, const char *Quelle);
int strcmp(const char *s1, const char *s2);
char *strcpy(char *Ziel, const char *Quelle);
size_t strlen(const char *s);
char *strncat(char *Ziel, const char *Quelle, size_t n);
int strncmp(const char *s1, const char *s2, size_t n);
char *strncpy(char *Ziel, const char *Quelle, size_t n);
char *strstr(const char *Heuhaufen, const char *Nadel);

#include <stdlib.h>

int    atoi(const char *s);
long   atol(const char *s);
double atof(const char *s);

double atof(const char *ZahlenString, char DezimalZeichen)
{
double Wert = 0.0;
bool Negativ = false;

    // Vorzeichen bearbeiten
    if (*ZahlenString=='-')
    {
        Negativ = true;
        ZahlenString++;
    }
    else if (*ZahlenString=='+')
    {
        ZahlenString++;
    }
    // Vorkommastellen berechnen
    while (*ZahlenString>='0' && *ZahlenString<='9')
    {
        Wert *= 10;
        Wert += (*ZahlenString++ - '0');
    }

    if (*ZahlenString == DezimalZeichen )
    {
        // Nachkommastellen berechnen
        double NachkommaPotenz=1.0;
        ZahlenString++;
        while (*ZahlenString>='0' && *ZahlenString<='9')
        {
            NachkommaPotenz /= 10;
            Wert += (*ZahlenString++ - '0') * NachkommaPotenz;
        }
    }
    // Vorzeichen berücksichtigen
    if (Negativ)
    {
        Wert = -Wert;
    }
    return Wert;
}

#include <stdio.h>

int printf(const char *Format, ...);
int fprintf(FILE *stream, const char *Format, ...);
int sprintf(char *String, const char *Format, ...);

Die Funktion sprintf() soll hier näher betrachtet werden, weil sie auch in C++-Programmen häufig benutzt wird, um Zahlen oder Tabellen zu formatieren. Die Funktion ist vor allem bei der Ausgabe von Festkommawerten flexibler als die Manipulatoren.

Der erste Parameter der Funktion sprintf() ist der C-String, der nach dem Aufruf das Ergebnis enthält. Er ist großzügig zu bemessen, da sprintf() nicht prüfen kann, ob die Kapazität überschritten wird. Der zweite Parameter ist der Format-String, der angibt, wie die nachfolgenden Parameter dargestellt werden sollen. Die weiteren Parameter enthalten die Werte, die aufbereitet werden sollen. Die drei Punkte sind kein Zeichen für Ratlosigkeit, sondern ein Syntaxelement der Sprache C für beliebig viele Parameter.

Format-String

sprintf(OutStr, "%s %s hat Kundennr. %d und %7.2f EUR Guthaben",
       VornameStr, NameStr, KdNr, Guthaben);

Die Variable OutStr sollte ein char-Array sein und wird nach der Ausführung des Befehls die Ausgabe von sprintf() enthalten. Der Formatstring enthält zunächst zwei String-Platzhalter (%s). Die nächsten zwei Parameter - hier sind es VornameStr und NameStr - müssen C-Strings sein. Der Text im Format-String >>hat Kundennr.<< wird danach in OutStr zu finden sein. Als nächstes wird ein ganzzahlige, dezimal dargestellter Wert erwartet (%d). Der Paramter KdNr sollte also ein Integer sein. Der letzte Platzhalter (%7.2f) stellt einen Fließkommawert mit festen sieben Vorkomma- und zwei Nachkommastellen dar. Es wird also der Format-String in die Zielvariable kopiert und die Platzhalterstellen durch die nachfolgenden Parameter aufgefüllt. Ein Platzhalter beginnt immer mit dem Prozentzeichen und endet mit dem Typkennzeichnungsbuchstaben. Die folgende Tabelle zeigt eine Zusammenfassung. [Typkennzeichen im printf-Format-String]

Typkennzeichen	Bedeutung
d	Dezimale Darstellung eines Ganzzahlwertes
x	Hexadezimale Darstellung eines Ganzzahlwertes
f	Festkommadarstellung eines double-Wertes
e	Exponentialdarstellung eines double-Wertes
c	Ein Zeichen darstellen
s	Einen C-String darstellen

Platzhalter

Flags

Spaltenbreite

Modifizierer

sprintf(ZielString, "%d", ZahlenWert);