• Standardklasse string
  • Iterator statt Zeiger
  • Umwandlung zwischen Zahlen und Zeichenketten
• Andere String-Bibliotheken
• String als char-Array
  • Klassische C-Funktionen
  • Strings in Zahlen konvertieren
  • Zahlen in Strings konvertieren

Standardklasse string

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] = "alt";
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
}

Iterator statt Zeiger

Die Klasse string bietet als Ersatz eine Art Zeiger an, die Iterator genannt wird. Den Typ des Iterators bringt die string-Klasse gleich mit. Er lautet string::iterator. In den allermeisten Fällen werden Sie den Iterator zunächst auf den Anfangs des Strings setzen wollen. Dazu bietet die Klasse string die Elementfunktion begin() an. Sie hat keine Parameter und liefert einen Iterator zurück. Der Iterator kann inkrementiert werden wie ein gewöhnlicher Zeiger. Um das Ende des Strings zu erkennen, gibt es die Elementfunktion end(), die ebenfalls einen Iterator zurückgibt. Dieser Iterator zeigt hinter den letzten gültigen Buchstaben des Strings. Sobald der Iterator gleich dem von end() gelieferten ist, hat er das Ende des Strings überschritten. Über den Iterator kann wie beim Zugriff über einen Zeiger auf das jeweilige Element zugegriffen werden, indem dem Iterator ein Stern vorangestellt wird.

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

String-Streams

Zeichenkette nach Zahl

#include <sstream>
using namespace std;

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

Zahl nach Zeichenkette

#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

String als char-Array

char name[20];
name[0] = 'K';
name[1] = 'a';
name[2] = 'i';

char name[20];
name[0] = 'K';
name[1] = 'a';
name[2] = 'i';
name[3] = 0; // oder '\0', was das Gleiche ist

char name[20] = "Kai";

#include <iostream>
using namespace std;

int main()
{
    char name[20] = "Willemer";
    cout << "Geben Sie Ihren Namen ein: ";
    cin >> name;
    cout << "Ihr Name lautet " << name << endl;
    // Schauen wir auf jedes char im Array:
    for (int i=0; i<20; i++) {
         cout << name[i] << ' ';
    }
    cout << endl;
}

Speicheranforderung

Abschluss-Null

Klassische C-Funktionen

Selbstgestrickt

[strcpy() selbst geschrieben]

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

Stringkopie

Um dies zu verhindern, gibt es die Funktion strncpy(), die als weiteren Parameter die maximale Länge des zu kopierenden Bereichs erwartet. Damit ist ein Überschreiten der Grenzen des Ziel-Arrays leicht vermeidbar. Leider schließt strncpy() den Zielstring nicht mit einer 0 ab, wenn die Länge des Quellstrings den dritten Parameter überschreitet. Es werden einfach exakt so viele Zeichen kopiert, wie der dritte Parameter angibt. Damit das Ziel-Array auf jeden Fall korrekt abgeschlossen ist, sollten Sie grundsätzlich nach dem Aufruf von strncpy() das letzte Element des Ziel-Arrays auf 0 setzen. Das folgende Beispiel zeigt, wie das geht:

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

Strings verbinden

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

Stringlänge

Stringvergleich

Teilstring suchen

#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);

Strings in Zahlen konvertieren

atoi()

#include <stdlib.h>

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

Die Funktion atof() hat den Nachteil, dass sie nur einen Punkt als Dezimalzeichen akzeptiert. Im deutschsprachigen Raum wird aber ein Anwender lieber ein Komma verwenden. Dies wiederum wird von atof() als Ende der Zahl interpretiert, so dass die Nachkommastellen fehlen. Um die Verwendung eines Kommas als Dezimalzeichen zu ermöglichen, können wir eine eigene Funktion atof schreiben, die als zweiten Parameter ein beliebiges Dezimalzeichen akzeptiert.

[atof überladen]

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;
}

Übung

• Schreiben Sie eine Funktion atof() mit den gleichen Parametern wie oben. Nutzen Sie aber die Stringfunktionen, um das Komma aufzuspüren und durch einen Punkt zu ersetzen und das Ergebnis der Standardfunktion atof() zuzuführen.

Zahlen in Strings konvertieren

#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);

• Warum UTF-8 bevorzugt werden sollte