• Es wird ausgehend vom Namen gelesen.
• Steht etwas rechts vom Namen, wird es ausgewertet.
• Steht rechts nichts mehr, wird der Teil auf der linken Seite ausgewertet.
• Mit Klammern kann die Reihenfolge geändert werden.

Die folgenden Beispiele werden zeigen, dass diese Regeln immer gelten:

int i;            // i ist ein int
int *j;           // j ist ein Zeiger auf int
int k[6];         // k ist ein Array von sechs Elementen des Typs int
int *l[6];        // l ist ein Array von sechs Elementen des Typs Zeiger auf int
int (*m)[6];      // m ist ein Zeiger auf ein Array von sechs Elementen des Typs int
int *(*&n)[6];    // n ist eine Referenz auf einen Zeiger auf ein Array von
                  // sechs Elementen des Typs Zeiger auf int
int *(*o[6])[5];  // o ist ein Array von sechs Elementen des Typs Zeiger auf ein
                  // Array von fünf Elementen des Typs Zeiger auf int
int **(*p[6])[5]; // p ist Array von sechs Elementen des Typs Zeiger auf ein Array
                  // von fünf Elementen des Typs Zeiger auf Zeiger auf int

Nehmen Sie sich die Zeit, die Beispiele nachzuvollziehen. Wenn Sie keine Probleme damit haben, sehen Sie sich das nächste sehr komplexe Beispiel an. Es soll die allgemeine Gültigkeit dieser Regel noch einmal demonstrieren:

int (*(*(**pFunc[5])(int*, double&))[6])();

pFunc ist ein Array mit fünf Elementen, das Zeiger auf Zeiger auf Funktionen enthält, die einen Zeiger auf int und eine Referenz auf double übernehmen und einen Zeiger auf Arrays mit sechs Elementen vom Typ Zeiger auf Funktionen, ohne Parameter, mit einem int als Rückgabewert zurückgeben. Einem solchen Monstrum werden Sie beim Programmieren wahrscheinlich selten bis nie begegnen, aber falls doch, können Sie es mit den obengenannten Regeln ganz einfach entschlüsseln. Wenn Sie nicht in der Lage sind, dem Beispiel noch zu folgen, brauchen Sie sich keine Gedanken zu machen: Nur wenige Menschen sind in der Lage, sich ein solches Konstrukt überhaupt noch vorzustellen. Wenn Sie es nachvollziehen können, kommen Sie sehr wahrscheinlich mit jeder Datentypdeklaration klar.

Zeichenketten

[Bearbeiten] Einleitung

In C++ gibt es keinen eingebauten Datentyp für Zeichenketten, lediglich einen für einzelne Zeichen. Da es in C noch keine Klassen gab, bediente man sich dort der einfachsten Möglichkeit, aus Zeichen Zeichenketten zu bilden: Man legte einfach einen Array von Zeichen an. C++ bietet eine komfortablere Lösung an: Die C++-Standardbibliothekenthält eine Klasse namens string. Um diese Klasse nutzen zu können, müssen Sie die gleichnamige Headerdatei string einbinden.

#include <iostream>
#include <string>

int main() {
    std::string zeichenkette;
    zeichenkette = "Hallo Welt!";
    std::cout << zeichenkette << std::endl;
}

Ausgabe:

Hallo Welt!

Wir werden uns in diesem Kapitel mit der C++-Klasse string auseinandersetzen. Am Ende des Kapitels beleuchten wir den Umgang mit C-Strings (also char-Arrays) etwas genauer. Natürlich liegt auch string, wie alle Teile der Standardbibliothek, im Namensraum std.

[Bearbeiten] Wie entsteht ein string-Objekt?

Zunächst sind einige Worte zur Notation von Zeichenketten in doppelten Anführungszeichen nötig. Wie Ihnen bereits bekannt ist, werden einzelne Zeichen in einfachen Anführungszeichen geschrieben. Dieser Zeichenliteral ist dann vom Typ char. Die doppelten Anführungszeichen erzeugen hingegen eine Instanz eines char-Arrays. "Hallo Welt!" ist zum Beispiel vom Typ char[12].

Es handelt sich also um eine Kurzschreibweise, zum Erstellen von char-Arrays, damit Sie nicht {'H', 'a', 'l', 'l', 'o', ' ', 'W', 'e', 'l', 't', '!', '\0'} schreiben müssen, um eine einfache Zeichenkette zu erstellen. Was ist das '\0' und warum ist das Array 12 chars lang ist, obwohl es nur 11 Zeichen enthält? Wie bereits erwähnt, ist ein C-String ein Array von Zeichen. Da ein solcher C-String natürlich im Programmablauf Zeichenketten unterschiedlicher Längen enthalten konnte, beendete man die Zeichenkette durch ein Endzeichen: '\0' (Zahlenwert 0). Somit musste ein Array von Zeichen in C immer ein Zeichen länger sein, als die längste Zeichenkette, die im Programmverlauf darin gespeichert wurde.

Diese Kurzschreibweise kann aber noch mehr, als man auf den ersten Blick vermuten würde. Die eben genannte lange Notation zur Initialisierung eines Arrays funktioniert im Quelltext nur, wenn der Compiler auch weiß, von welchem Datentyp die Elemente des Arrays sein sollen. Da Zeichenliterale jedoch implizit in größere integrale Typen umgewandelt werden können, kann er den Datentyp nicht vom Typ der Elemente, die für die Initialisierung genutzt wurden ableiten:

#include <string>

int main() {
    // char-Array mit 12 Elementen
    char a[] = {'H', 'a', 'l', 'l', 'o', ' ', 'W', 'e', 'l', 't', '!', '\0'};

    // int-Array mit 12 Elementen
    int  b[] = {'H', 'a', 'l', 'l', 'o', ' ', 'W', 'e', 'l', 't', '!', '\0'};

    // char-Array mit 12 Elementen
    std::string z = {'H', 'a', 'l', 'l', 'o', ' ', 'W', 'e', 'l', 't', '!', '\0'};
}

Bei der Notation mit geschweiften Klammern ist dagegen immer bekannt, dass es sich um ein char-Array handelt. Entsprechend ist die Initialisierung eines int-Arrays damit nicht möglich. Folgendes dagegen schon:

#include <string>

int main() {
    // char-Array mit 12 Elementen
    char a[] = "Hallo Welt!";

    // char-Array mit 12 Elementen
    std::string z = "Hallo Welt!";
}

Bei der Erzeugung eines string-Objekts wird eine Funktion aufgerufen, die sich Konstruktor nennt. Was genau ein Konstruktor ist, erfahren Sie im Kapitel über Klassen. In unserem Fall wird also der Konstruktor für das string-Objekt z aufgerufen. Als Parameter erhält er das char-Array "Hallo Welt!". Wie Ihnen bereits bekannt ist, können an Funktionen keine Arrays übergeben werden. Stattdessen wird natürlich ein Zeiger vom Arrayelementtyp (also char) übergeben. Dabei geht aber die Information verloren, wie viele Elemente dieses Array enthält und an dieser Stelle kommt das '\0'-Zeichen (Nullzeichen) ins Spiel. Anhand dieses Zeichens kann auch innerhalb der Zeichenkette erkannt werden, wie lang die übergebene Zeichenkette ist.

Damit wissen Sie nun, wie aus dem einfachen char-Array das fertige string-Objekt wird. Jetzt ist es an der Zeit zu erfahren, was Sie mit diesem Objekt alles machen können

[Bearbeiten] string und andere Datentypen

Wie Sie bereits im Beispiel von eben gesehen haben, lässt sich die string-Klasse problemlos mit anderen Datentypen und Klassen kombinieren. Im ersten Beispiel dieses Kapitels wurde zunächst eine Zuweisung eines char-Arrays vorgenommen. Anschließend wurde das string-Objekt über cout ausgegeben. Auch die Eingabe einer Zeichenkette über cin ist mit einem string-Objekt problemlos möglich:

#include <iostream>
#include <string>

int main() {
    std::string zeichenkette;

    std::cin >> zeichenkette;
    std::cout << zeichenkette;
}

Diese Art der Eingabe erlaubt es lediglich, bis zum nächsten Whitespace einzulesen. Es kommt jedoch häufig vor, dass man eine Zeichenkette bis zum Zeilenende oder einem bestimmten Endzeichen einlesen möchte. In diesem Fall ist die Funktion getline hilfreich. Sie erwartet als ersten Parameter einen Eingabestream und als zweiten ein string-Objekt.

#include <iostream>
#include <string>

int main() {
    std::string zeichenkette;

    // Liest bis zum Zeilenende
    std::getline(std::cin, zeichenkette);
    std::cout << zeichenkette;
}

Als optionalen dritten Parameter kann man das Zeichen angeben, bis zu dem man einlesen möchte. Im Fall von eben wurde als der Default-Parameter '\n' (Newline-Zeichen) benutzt. Im folgenden Beispiel wird stattdessen bis zum ersten kleinen y eingelesen.

#include <iostream>
#include <string>

int main() {
    std::string zeichenkette;

    // Liest bis zum nächsten y
    std::getline(std::cin, zeichenkette, 'y');
    std::cout << zeichenkette;
}

[Bearbeiten] Zuweisen und Verketten

Genau wie die Basisdatentypen, lassen sich auch strings einander zuweisen. Für die Verkettung von strings wird der +-Operator benutzt und das Anhängen einer Zeichenkette ist mit += möglich.

#include <iostream>
#include <string>

int main() {
    std::string string1, string2, string3;

    string1 = "ich bin ";
    string2 = "doof";
    string3 = string1 + string2;
    std::cout << string3 << std::endl;

    string3 += " - " + string1 + "schön";
    std::cout << string3 << std::endl;

    std::cout << string1 + "schön " + string2 << std::endl;
}

Ausgabe:

ich bin doof
ich bin doof - ich bin schön
ich bin schön doof

Spielen Sie einfach ein wenig mit den Operatoren, um den Umgang mit ihnen zu lernen.

[Bearbeiten] Nützliche Methoden

Die string-Klasse stellt einige nützliche Methoden bereit. Etwa um den String mit etwas zu füllen, ihn zu leeren oder über verschiedene Eigenschaften Auskunft zu bekommen. Eine Methode wird mit folgender Syntax aufgerufen:

Syntax:

«stringname».«methodenname»(«parameter...»);

Die Methoden size() und length() erwarten keine Parameter und geben beide die aktuelle Länge der gespeicherten Zeichenkette zurück. Diese Doppelung in der Funktionalität existiert, da string in Analogie zu den anderen Containerklassen der C++-Standardbibliothek size() anbieten muss, der Name length() für die Bestimmung der Länge eines Strings aber natürlicher und auch allgemein üblich ist. empty() gibt true zurück falls der String leer ist, andernfalls false.

Mit clear() lässt sich der String leeren. Die resize()-Methode erwartet ein oder zwei Parameter. Der erste ist die neue Größe des Strings, der zweite das Zeichen, mit dem der String aufgefüllt wird, falls die angegebene Länge größer ist, als die aktuelle. Wird der zweite Parameter nicht angegeben, wird der String mit '\0' (Nullzeichen) aufgefüllt. In der Regel werden Sie dieses Verhalten nicht wollen, geben Sie also ein Füllzeichen an, falls Sie sich nicht sicher sind, was Sie tun. Ist die angegebene Länge geringer, als die des aktuellen Strings, wird am Ende abgeschnitten.

Um den Inhalt zweier Strings auszutauschen existiert die swap()-Methode. Sie erwartet als Parameter den String mit dem ihr Inhalt getauscht werden soll. Dies ist effizienter, als das Vertauschen über eine dritte, temporäre string-Variable.

#include <iostream>
#include <string>

int main() {
    std::string zeichenkette1 = "Ich bin ganz lang!";
    std::string zeichenkette2 = "Ich kurz!";

    std::cout << zeichenkette1 << std::endl;
    std::cout << zeichenkette2 << std::endl;

    zeichenkette1.swap(zeichenkette2);

    std::cout << zeichenkette1 << std::endl;
    std::cout << zeichenkette2 << std::endl;
}

Ausgabe:

Ich bin ganz lang!
Ich kurz!
Ich kurz!
Ich bin ganz lang!

[Bearbeiten] Zeichenzugriff

Genau wie bei einem Array können Sie den []-Operator (Zugriffsoperator) verwenden, um auf einzelne Zeichen im String zuzugreifen. Allerdings wird, ebenfalls genau wie beim Array, nicht überprüft, ob der angegebene Wert noch innerhalb der enthaltenen Zeichenkette liegen.

Alternativ existiert die Methode at(), die den Index als Parameter erwartet und eine Grenzprüfung ausführt. Im Fehlerfall löst sie eine out_of_range-Exception aus. Da Sie den Umgang mit Exceptions wahrscheinlich noch nicht beherrschen, sollten Sie diese Methode vorerst nicht einsetzen und stattdessen genau darauf achten, dass Sie nicht versehentlich über die Stringlänge hinaus zugreifen.

#include <iostream>
#include <string>

int main() {
    std::string zeichenkette = "Ich bin ganz lang!";

    std::cout << zeichenkette[4] << std::endl;
    std::cout << zeichenkette.at(4) << std::endl;

    std::cout << zeichenkette[20] << std::endl;    // Ausgabe von Datenmüll
    std::cout << zeichenkette.at(20) << std::endl; // Laufzeitfehler
}

Ausgabe:

b
b

terminate called after throwing an instance of 'std::out_of_range'
  what():  basic_string::at
Abgebrochen

Die Fehlerausgabe kann bei Ihrem Compiler anders aussehen.

Hinweis

Beachten Sie beim Zugriff, dass das erste Zeichen den Index 0 hat. Das letzte Zeichen hat demzufolge den Index zeichenkette.length() - 1.

[Bearbeiten] Manipulation

[Bearbeiten] Suchen

Die Methode find() sucht das erste Vorkommen eines Strings und gibt die Startposition (Index) zurück. Der zweite Parameter gibt an, ab welcher Position des Strings gesucht werden soll.

#include <iostream>
#include <string>

int main() {
    std::string str = "Zeichenkette";
    std::string find = "k";
    std::cout << str.find(find, 0);
}

Ausgabe:

7

Wird ein Substring nicht gefunden, gibt find() den Wert std::string::npos zurück.

Das Gegenstück zu find() ist rfind(). Es ermittelt das letzte Vorkommen eines Strings. Die Parameter sind die gleichen wie bei find().

[Bearbeiten] Ersetzen

Sie können replace() verwenden, um Strings zu ersetzen. Dafür benötigen Sie die Anfangsposition und die Anzahl der Zeichen, die anschließend ersetzt werden sollen.

#include <iostream>
#include <string>

int main() {
    std::string str = "Zeichenkette";
    str.replace(str.find("k"), std::string("kette").length(), "test");
    std::cout << str << std::endl;
}

Ausgabe:

Zeichentest

Wie Sie sehen, verwenden wir find(), um die Startposition zu ermitteln. Der zweite Parameter gibt die Länge an. Hier soll die alternative Schreibweise verdeutlicht werden; Sie müssen nicht eine zusätzliche Variable deklarieren, sondern können die std::string-Klasse wie eine Funktion verwenden und über Rückgabewert auf die Methode length() zugreifen. Im dritten Parameter spezifizieren Sie den String, welcher den ursprünglichen String zwischen der angegebenen Startposition und Startposition + Länge ersetzt.

[Bearbeiten] Einfügen

Die Methode insert() erlaubt es Ihnen, einen String an einer bestimmten Stelle einzufügen.

#include <iostream>
#include <string>

int main() {
    std::string str = "Hallo Welt.";
    str.insert(5, " schöne");
    std::cout << str << std::endl;
}

Ausgabe:

Hallo schöne Welt

[Bearbeiten] Kopieren

Mit der Methode substr() kann man sich einen Substring zurückgeben lassen. Der erste Parameter gibt den Startwert an. Zusätzlich kann man mit dem zweiten Parameter noch die Endposition festlegen. Wird die Methode nur mit dem Startwert aufgerufen, gibt sie alle Zeichen ab dieser Position zurück.

#include <iostream>
#include <string>

int main() {
    std::string str = "Hallo Welt.";
    std::cout << str.substr(0, str.find(' ')) << std::endl;
}
</source>

Ausgabe:

Hallo

[Bearbeiten] Vergleiche

C++-Strings können Sie, genau wie Zahlen, miteinander vergleichen. Was Gleichheit und Ungleichheit bei einem String bedeutet, wird Ihnen sofort klar sein. Sind alle Zeichen zweier Strings identisch, so sind beide gleich, andernfalls nicht. Die Operatoren <, >>, <= und >= geben da schon einige Rätsel mehr auf.

Im Grunde kennen Sie die Antwort bereits. Zeichen sind in C++ eigentlich Zahlen. Sie werden zu Zeichen, indem den Zahlen entsprechende Symbole zugeordnet werden. Der Vergleich erfolgt also einfach mit den Zahlen, welche die Zeichen kodieren. Das erste Zeichen der Strings, das sich unterscheidet, entscheidet darüber, welcher der Strings größer bzw. kleiner ist.

Die meisten Zeichenkodierungen beinhalten in den ersten 7 Bit den ASCII-Code, welchen die nachfolgende Tabelle zeigt.

ASCII-Codetabelle, Nummerierung im Hexadezimalsystem (Teil 1) Code …0 …1 …2 …3 …4 …5 …6 …7 0… NUL SOH STX ETX EOT ENQ ACK BEL 1… DLE DC1 DC2 DC3 DC4 NAK SYN ETB 2… SP ! " # $ % & ' 3… 0 1 2 3 4 5 6 7 4… @ A B C D E F G 5… P Q R S T U V W 6… ` a b c d e f g 7… p q r s t u v w

ASCII-Codetabelle, Nummerierung im Hexadezimalsystem (Teil 2) Code …8 …9 …A …B …C …D …E …F 0… BS HT LF VT FF CR SO SI 1… CAN EM SUB ESC FS GS RS US 2… ( ) * + , - . / 3… 8 9 : ; < = > ? 4… H I J K L M N O 5… X Y Z [ \ ] ^ _ 6… h i j k l m n o 7… x y z { | } ~ DEL

#include <string>

int main(){
    std::string gross = "Ich bin ganz groß!";
    std::string klein = "Ich bin ganz klein!";

    gross == klein; // ergibt false ('g' != 'k')
    gross != klein; // ergibt true  ('g' != 'k')
    gross <  klein; // ergibt true  ('g' <  'k')
    gross >  klein; // ergibt false ('g' <  'k')
    gross <= klein; // ergibt true  ('g' <  'k')
    gross >= klein; // ergibt false ('g' <  'k')
}

[Bearbeiten] Zahl zu string und umgekehrt

In C++ gibt es, im Gegensatz zu vielen anderen Programmiersprachen, keine Funktion, um direkt Zahlen in Strings oder umgekehrt umzuwandeln. Es ist allerdings nicht besonders schwierig, eine solche Funktion zu schreiben. Wir haben für die Umwandlung zwei Möglichkeiten:

• Die C-Funktionen atof(), atoi(), atol() und sprintf()
• C++-String-Streams

Die C-Variante wird in Kürze im Zusammenhang mit C-Strings besprochen. Für den Moment wollen wir uns der C++-Variante widmen. Stringstreams funktionieren im Grunde genau wie die Ihnen bereits bekannten Ein-/Ausgabestreams cin und cout mit dem Unterschied, dass sie ein string-Objekt als Ziel benutzen.

#include <iostream> // Standard-Ein-/Ausgabe
#include <sstream>  // String-Ein-/Ausgabe

int main() {
    std::ostringstream strout; // Unser Ausgabe-Stream
    std::string str;           // Ein String-Objekt
    int var = 10;              // Eine ganzzahlige Variable

    strout << var;             // ganzzahlige Variable auf Ausgabe-Stream ausgeben
    str = strout.str();        // Streaminhalt an String-Variable zuweisen

    std::cout << str << std::endl; // String ausgeben
}

Der vorliegende Code wandelt eine Ganzzahl in einen String um, indem die Ganzzahl auf dem Ausgabe-Stringstream ausgegeben und dann der Inhalt des Streams an den String zugewiesen wird. Die umgekehrte Umwandlung funktioniert ähnlich. Natürlich verwenden wir hierfür einen Eingabe-Stringstream ( istringstream statt ostringstream) und übergeben den Inhalt des Strings an den Stream, bevor wir ihn von diesem auslesen.

#include <iostream> // Standard-Ein-/Ausgabe
#include <sstream>  // String-Ein-/Ausgabe

int main() {
    std::istringstream strin; // Unser Eingabe-Stream
    std::string str = "17";   // Ein String-Objekt
    int var;                  // Eine ganzzahlige Variable

    strin.str(str);           // Streaminhalt mit String-Variable füllen
    strin >> var;             // ganzzahlige Variable von Eingabe-Stream einlesen

    std::cout << var << std::endl; // Zahl ausgeben
}

Statt istringstream und ostringstream können Sie übrigens auch ein stringstream-Objekt verwenden, welches sowohl Ein-, als auch Ausgabe erlaubt, allerdings sollte man immer so präzise wie möglich angeben, was der Code machen soll. Daher ist die Verwendung eines spezialisierten Streams zu empfehlen, wenn Sie nur die speziellen Fähigkeiten (Ein- oder Ausgabe) benötigen.

Sicher sind Sie jetzt bereits in der Lage, zwei Funktionen zu schreiben, welche diese Umwandlung durchführt. Allerdings stehen wir in dem Moment, wo wir andere Datentypen als int in Strings umwandeln wollen vor einem Problem. Wir können der folgenden Funktion zwar ohne weiteres eine double-Variable übergeben, allerdings wird dann der Nachkommateil einfach abgeschnitten. Als Lösung kommt Ihnen nur eventuell in den Sinn, einfach eine double-Variable von der Funktion übernehmen zu lassen.

#include <iostream> // Standard-Ein-/Ausgabe
#include <sstream>  // String-Ein-/Ausgabe

std::string zahlZuString(double wert) {
    std::ostringstream strout; // Unser Ausgabe-Stream
    std::string str;           // Ein String-Objekt

    strout << wert;            // Zahl auf Ausgabe-Stream ausgeben
    str = strout.str();        // Streaminhalt an String-Variable zuweisen

    return str;                // String zurückgeben
}

int main() {
    std::string str;
    int    ganzzahl  = 19;
    double kommazahl = 5.55;

    str = zahlZuString(ganzzahl);
    std::cout << str << std::endl;

    str = zahlZuString(kommazahl);
    std::cout << str << std::endl;
}

Ausgabe:

19
5.55

Nun, so weit so gut. Das funktioniert. Leider gibt es da aber auch noch die umgekehrte Umwandlung und obgleich es möglich ist, sie auf ähnliche Weise zu lösen, wird Ihr Compiler sich dann ständig mit einer Warnung beschweren, wenn das Ergebnis ihrer Umwandlung an eine ganzzahlige Variable zugewiesen wird.

Besser wäre es, eine ganze Reihe von Funktionen zu erzeugen, von denen jede für einen Zahlentyp verantwortlich ist. Tatsächlich können Sie in C++ mehrere Funktionen gleichen Namens erzeugen, die unterschiedliche Parameter(typen) übernehmen. Diese Vorgang nennt sich Überladen von Funktionen. Der Compiler entscheidet dann beim Aufruf der Funktion anhand der übergeben Parameter, welche Version gemeint war während der Programmierer immer den gleichen Namen verwendet.

Im Moment haben wir obendrein einen Sonderfall der Überladung. Alle unsere Funktionen besitzen exakt den gleichen Code. Lediglich der Parametertyp ist unterschiedlich. Es wäre ziemlich zeitaufwendig und umständlich, den Code immer wieder zu kopieren, um dann nur den Datentyp in der Parameterliste zu ändern. Noch schlimmer wird es, wenn wir eines Tages eine Änderung am Funktionsinhalt vornehmen und diese dann auf alle Kopien übertragen müssen.

Glücklicherweise bietet C++ für solche Fälle so genannte Templates, die es uns erlauben, den Datentyp vom Compiler ermitteln zu lassen. Wir teilen dem Compiler also mit, was er tun soll, womit muss er dann selbst herausfinden. Die Funktion zahlZuString() (umbenannt in toString()) sieht als Template folgendermaßen aus:

#include <iostream> // Standard-Ein-/Ausgabe
#include <sstream>  // String-Ein-/Ausgabe

template <typename Typ>
std::string toString(Typ wert) {
    std::ostringstream strout; // Unser Ausgabe-Stream
    std::string str;           // Ein String-Objekt

    strout << wert;            // Zahl auf Ausgabe-Stream ausgeben
    str = strout.str();        // Streaminhalt an String-Variable zuweisen

    return str;                // String zurückgeben
}

int main() {
    std::string str;
    int    ganzzahl  = 19;
    double kommazahl = 5.55;
    std::string nochnString = "Blödsinn";

    str = toString(ganzzahl);
    std::cout << str << std::endl;

    str = toString(kommazahl);
    std::cout << str << std::endl;

    str = toString(nochnString);
    std::cout << str << std::endl;
}

Ausgabe:

19
5.55
Blödsinn

Die letzte Ausgabe zeigt deutlich warum die Funktion in toString umbenannt wurde, denn sie ist nun in der Lage, jeden Datentyp, der sich auf einem ostringstream ausgeben lässt, zu verarbeiten und dazu zählen eben auch string-Objekte und nicht nur Zahlen. Sie werden später noch lernen, welches enorme Potenzial diese Technik in Zusammenhang mit eigenen Datentypen hat. An dieser Stelle sei Ihnen noch die Funktion zur Umwandlung von Strings in Zahlen (oder besser: alles was sich von einem istringstream einlesen lässt) mit auf den Weg gegeben:

#include <iostream> // Standard-Ein-/Ausgabe
#include <sstream>  // String-Ein-/Ausgabe

template <typename Typ>
void stringTo(std::string str, Typ &wert) {
    std::istringstream strin; // Unser Eingabe-Stream

    strin.str(str);           // Streaminhalt mit String-Variable füllen
    strin >> wert;            // Variable von Eingabe-Stream einlesen
}

int main() {
    std::string str = "7.65Blödsinn";
    int    ganzzahl;
    double kommazahl;
    std::string nochnString;

    stringTo(str, ganzzahl);
    std::cout << ganzzahl << std::endl;

    stringTo(str, kommazahl);
    std::cout << kommazahl << std::endl;

    stringTo(str, nochnString);
    std::cout << nochnString << std::endl;
}

Ausgabe:

7
7.65
7.65Blödsinn

Die Variable, die mit dem Wert des Strings belegt werden soll, wird als Referenz an die Funktion übergeben, damit der Compiler ihren Typ feststellen kann. Die Ausgabe zeigt, dass immer nur so viel eingelesen wird, wie der jeweilige Datentyp (zweiter Funktionsparameter) fassen kann. Für eine ganzzahlige Variable wird nur die Zahl Sieben eingelesen, die Gleitkommavariable erhält den Wert 7.65 und das string-Objekt kann die gesamte Zeichenkette übernehmen.

Thema wird später näher erläutert…

Sie werden Überladung im Kapitel „Überladen…“ (Abschnitt „Eigene Datentypen definieren“) genauer kennen lernen. Templates sind ein sehr umfangreiches Thema, Sie werden ihnen im Abschnitt Templates wiederbegegnen.

[Bearbeiten] C-Strings

Wie bereits erwähnt, handelt es sich bei einem C-String um ein Array von chars. Das Ende eines C-Strings wird durch ein Nullzeichen (Escape-Sequenz '\0') angegeben. Das Arbeiten mit C-Strings ist mühsam, denn es muss immer sichergestellt sein, dass das Array auch groß genug ist, um den String zu beinhalten. Da in C/C++ jedoch auch keine Bereichsüberprüfung durchgeführt wird, macht sich ein Pufferüberlauf (also eine Zeichenkette die größer ist als das Array, das sie beinhaltet) erst durch einen eventuellen Programmabsturz bemerkbar. Allein um dies zu vermeiden sollten Sie, wann immer es Ihnen möglich ist, die C++-string-Klasse verwenden.

Ein weiteres Problem beim Umgang mit C-Strings ist der geringe Komfort beim Arbeiten. Ob Sie einen String mit einem anderen vergleichen wollen, oder ihn an ein anderes Array „zuweisen“ möchten, in jedem Fall benötigen Sie unintuitive Zusatzfunktionen. Diese Funktionen finden Sie in der Standardheaderdatei „cstring“. Wie diese Funktionen heißen und wie man mit ihnen umgeht können Sie im C++-Referenz-Buch nachlesen, falls Sie sie einmal benötigen sollten.

Buchempfehlung

Wenn Sie sich eingehender mit der Thematik auseinandersetzen möchten, sei Ihnen das Buch C-Programmierung ans Herz gelegt. Wenn Sie in C++ mit der C-Standard-Bibliotheken arbeiten möchten, müssen Sie den Headerdateien ein „c“ voranstellen und das „.h“ weglassen. So wird beispielsweise aus dem C-Header „string.h“ der C++-Header „cstring“.

Vorarbeiter des Compilers

Bevor der Compiler eine C++-Datei zu sehen kriegt, läuft noch der Präprozessor durch. Er überarbeitet den Quellcode, sodass der Compiler daraus eine Objektdatei erstellen kann. Diese werden dann wiederum vom Linker zu einem Programm gebunden. In diesem Kapitel soll es um den Präprozessor gehen, wenn Sie allgemeine Informationen über Präprozessor, Compiler und Linker brauchen, dann lesen Sie das Kapitel „Compiler“.

[Bearbeiten] #include

Die Präprozessordirektive #include haben Sie schon häufig benutzt. Sie fügt den Inhalt der angegebenen Datei ein. Dies ist nötig, da der Compiler immer nur eine Datei übersetzen kann. Viele Funktionen werden aber in verschiedenen Dateien benutzt. Daher definiert man die Prototypen der Funktionen (und einige andere Dinge, die Sie noch kennenlernen werden) in so genannten Headerdateien. Diese Headerdateien werden dann über #include eingebunden, weshalb Sie die Funktionen usw. Aufrufen können.

Thema wird später näher erläutert…

Ausführlich Informationen über Headerdateien erhalten Sie im gleichnamigen Kapitel.

#include bietet zwei Möglichkeiten Headerdateien einzubinden:

#include "name" // Sucht im aktuellen Verzeichnis und dann in den Standardpfaden des Compilers
#include <name> // Sucht gleich in den Standardpfaden des Compilers

„Aktuelles Verzeichnis“ bezieht sich immer auf das Verzeichnis, in welchem die Datei liegt.

Die erste Syntax funktioniert immer, hat aber den Nachteil, dass dem Compiler nicht mitgeteilt wird, dass es sich um eine Standardheaderdatei handelt. Wenn sich im aktuellen Verzeichnis beispielsweise eine Datei namens iostream befände und Sie versuchten über die erste Syntax, die Standardheaderdatei iostream einzubinden, bänden Sie stattdessen die Datei im aktuellem Verzeichnis ein, was sehr unwahrscheinlich sein sollte, da Sie hoffentlich immer Dateiendungen wie .hpp oder .h für Ihre eigenen Header verwenden. Außerdem verlängert das Einbinden von Standardheadern in Anführungszeichen den Präprozessordurchlauf, je nach Anzahl der Dateien im aktuellen Quellpfad.

Aus diesem Grund ist es wichtig zu wissen, ob der eingebundene Header für eine Bibliotheksfunktionalität in den vordefinierten Pfaden des verwendeten Compilers steht, oder ob es eigener Inhalt ist, oder es sich um Zusatzbibliotheken handelt, deren Include-Verzeichnisse an anderen Stellen zu finden sind. Es sollte die Variante gewählt werden, bei der sich die Headerdatei vom Präprozessor am schnellsten finden lässt.

Tipp

Verwenden Sie für Verweise auf Ihre eigenen Includes immer eine relative Pfadangabe mit normalen Slashes '/' als Verzeichnisseparator, damit Sie Ihre Quellcodeverzeichnisse auch an anderen Stellen und in anderen Entwicklungsumgebungen schneller kompiliert bekommen. Eine Verzeichnisangabe wie "/home/ichuser/code/cpp/projekt/zusatzlib/bla.h" oder "c:\users\manni\Eigene Dateien\code\cpp\projekt\zusatzlib\bla.h" ist sehr unangenehm und sorgt für große Verwirrung. Schreiben Sie es nun in "../zusatzlib/bla.h" um, können Sie später Ihr gesamtes Projekt leichter in anderen Pfaden kompilieren und sparen sich selbst und Ihrem Präprozessor einiges an Ärger und Verwirrung.

[Bearbeiten] #define und #undef

#define belegt eine Textsubstitution mit dem angegebenen Wert, z.B.:

#define BEGRUESSUNG "Hallo Welt!\n"
cout << BEGRUESSUNG;

Makros sind auch möglich, z.B.:

#define ADD_DREI(x,y,z) x+y+z+3
int d(1),e(20),f(4),p(0);
p = ADD_DREI(d,e,f);              // p = d+e+f+3;

Diese sind allerdings mit Vorsicht zu genießen, da durch die strikte Textsubstitution des Präprozessors ohne jegliche Logikprüfungen des Compilers, fatale Fehler einfließen können und sollten eher durch ( inline)-Funktionen, Konstanten oder sonstige Konzepte realisiert werden. Manchmal lässt es sich allerdings nicht umgehen, ein Makro (weiter) zu verwenden. Beachten Sie bitte immer, dass es sich hierbei um Anweisungen an eine Rohquelltextvorbearbeitungsstufe handelt und nicht um Programmcode.

Da anstelle von einfachen Werten auch komplexere Terme als Parameter für das Makro verwendet werden können und das Makro selbst auch in einen Term eingebettet werden kann, sollten immer Klammern verwendet werden. Bsp.:

#define MUL_NOK(x,y) x*y
#define MUL_OK(x,y) ((x)*(y))

resultNok = a * MUL_NOK(b,c+d); // a * b*c+d      = a*b*c+d        <= falsch
resultOk = a * MUL_OK(b,c+d);   // a * ((b)*(c+d)) = a*b*c + a*b*d  <= richtig

#undef löscht die Belegung einer Textsubstitution/Makro, z.B.:

#undef BEGRUESSUNG

Buchempfehlung

Bitte denken Sie bei allen Ideen, auf die Sie nun kommen, dass Sie immer eine Alternative zur Makroprogrammierung haben. Verwenden Sie diese Makros vor allem als Zustandsspeicher für den Präprozessordurchlauf an sich und nicht um Funktionalitäten Ihres Programms zu erweitern.

Einer statischen, konstanten Defintion, sowie Templatefunktionen ist immer der Vorzug zu geben. Wenn Sie dies nicht so sehen, lesen Sie bitte hier weiter: C-Programmierung.

[Bearbeiten] #

Der #-Ausdruck erlaubt es, den einem Makro übergebenen Parameter als Zeichenkette zu interpretieren:

#define STRING(s) #s
cout << STRING(Test) << endl;

Das obige Beispiel gibt also den Text "Test" auf die Standard-Ausgabe aus.

[Bearbeiten] ##

Der ##-Ausdruck erlaubt es, in Makros definierte Strings innerhalb des Präprozessorlaufs miteinander zu kombinieren, z.B.:

#define A "Hallo"
#define B "Welt"
#define A_UND_B A##B

Als Resultat beinhaltet die Konstante A_UND_B die Zeichenkette "HalloWelt". Der ##-Ausdruck verbindet die Namen der symbolischen Konstanten, nicht deren Werte. Ein weiteres Anwendungsbeispiel:

#define MAKE_CLASS( NAME )       \
class NAME                       \
{                                \
  public:                        \
    static void Init##NAME() {}; \
};
...
MAKE_CLASS( MyClass )
...
MyClass::InitMyClass();

[Bearbeiten] #if, #ifdef, #ifndef, #else, #elif und #endif

Direktiven zur bedingten Übersetzung, d.h. Programmteile werden entweder übersetzt oder ignoriert.

#if ''Ausdruck1''
// Programmteil 1
#elif ''Ausdruck2''
// Programmteil 2
/*
   ...
 */
#else
// Programmteil sonst
#endif

Die Ausdrücke hinter #if bzw. #elif werden der Reihe nach bewertet, bis einer von ihnen einen von 0 verschiedenen Wert liefert. Dann wird der zugehörige Programmteil wie üblich verarbeitet, die restlichen werden ignoriert. Ergeben alle Ausdrücke 0, wird der Programmteil nach #else verarbeitet, sofern vorhanden.

Als Bedingungen sind nur konstante Ausdrücke erlaubt, d.h. solche, die der Präprozessor tatsächlich auswerten kann. Definierte Makros werden dabei expandiert, verbleibende Namen durch 0L ersetzt. Insbesondere dürfen keine Zuweisungen, Funktionsaufrufe, Inkrement- und Dekrementoperatoren vorkommen. Das spezielle Konstrukt

#defined ''Name''

wird durch 1L bzw. 0L ersetzt, je nachdem, ob das Makro Name definiert ist oder nicht.

#ifdef ist eine Abkürzung für #if defined.

#ifndef ist eine Abkürzung für #if ! defined.

Beispiel: Nehmen wir an, dass Sie Daten in zusammengesetzten Strukturen immer an 4-Byte Grenzen ausrichten wollen. Verschiedene Compiler bieten hierfür verschiedene compilerspezifische Pragma-Direktiven. Da diese Konfiguration nicht im C++-Standard definiert ist, kann nicht sichergestellt werden, dass es eine allgemeingültige Anweisung hierfür gibt. Sie definieren daher mit #define in einer Headerdatei, die überall eingebunden ist, welchen Compiler Sie verwenden. Z.B. mit #define FLAG_XY_COMPILER_SUITE in einer Datei namens "compiler-config-all.hpp". Das gibt Ihnen die Möglichkeit, an Stellen, an denen Sie compilerspezifisches Verhalten verwenden wollen, dieses auch auszuwählen.

#include "compiler-config-all.hpp"
#ifdef WIN32
#pragma pack(4)
#elif USING_GCC
#pragma align=4
#elif FLAG_XY_COMPILER_SUITE
#pragma ausrichtung(byte4)
#endif

[Bearbeiten] #error und #warning

#error gibt eine Fehlermeldung während des Compilerlaufs aus und bricht den Übersetzungsvorgang ab, z.B.:

#error Dieser Quellcode-Abschnitt sollte nicht mit compiliert werden!

#warning ist ähnlich wie #error, mit dem Unterschied, dass das Kompilieren nicht abgebrochen wird. Es ist allerdings nicht Teil von ISO-C++, auch wenn die meisten Compiler es unterstützen. Meistens wird es zum Debuggen eingesetzt:

#warning Dieser Quellcode-Abschnitt muss noch überarbeitet werden.

[Bearbeiten] #line

Setzt den Compiler-internen Zeilenzähler auf den angegebenen Wert, z.B.:

#line 100

[Bearbeiten] #pragma

Das #pragma-Kommando ist vorgesehen, um eine Reihe von Compiler-spezifischen Anweisungen zu implementieren, z.B.:

#pragma comment(lib, "advapi32.lib")

Kennt ein bestimmter Compiler eine Pragma-Anweisung nicht, so gibt er üblicherweise eine Warnung aus, ignoriert diese nicht für ihn vorgesehene Anweisung aber ansonsten.

Um z.B. bei MS VisualC++ eine "störende" Warnung zu unterdrücken, gibt man folgendes an:

#pragma warning( disable: 4010 ) // 4010 ist Nummer der Warnung

[Bearbeiten] Vordefinierte Präprozessor-Variablen

• __LINE__: Zeilennummer
• __FILE__: Dateiname
• __DATE__: Datum des Präprozessoraufrufs im Format Monat/Tag/Jahr
• __TIME__: Zeit des Präprozessoraufrufs im Format Stunden:Minuten:Sekunden
• __cplusplus: Ist nur definiert, wenn ein C++-Programm verarbeitet wird

Headerdateien

Sie haben bereits mit 2 Headerdateien Bekanntschaft gemacht: iostream und string. Beide sind so genannte Standardheader, das heißt, sie sind in der Standardbibliothek jedes Compilers enthalten.

[Bearbeiten] Was ist eine Headerdatei?

Headerdateien sind gewöhnliche C++-Dateien, die im Normalfall Funktionsdeklarationen und ähnliches enthalten. Sicher werden Sie sich erinnern: Deklarationen machen dem Compiler bekannt, wie etwas benutzt wird. Wenn Sie also eine Headerdatei einbinden und darin eine Funktionsdeklaration steht, dann weiß der Compiler wie die Funktion aufgerufen wird. Der Compiler weiß zu diesem Zeitpunkt nicht, was die Funktion tut, aber das ist auch nicht nötig um sie aufrufen zu können.

Das einbinden einer Headerdatei erfolgt über die Präprozessordirektive #include. Der Code in der Datei die mit include referenziert wird, wird vom Präprozessor einfach an der Stelle eingefügt, an der das include stand.

In der nebenstehenden Darstellung wird die Headerdatei mal2.hpp von den Quelldateien main.cpp und mal2.cpp eingebunden. Um dieses Beispiel zu übersetzen, müssen die Dateien alle im gleichen Verzeichnis liegen. Sie übergeben die Quelldateien an einen Compiler und rufen anschließend den Linker auf, um die entstanden Objektdateien zu einem Programm zu binden.

Hinweis

Falls Sie mit der GCC arbeiten, beachten Sie bitte, dass g++ sowohl Compiler als auch Linker ist. Wenn Sie nur die beiden Quelldateien ohne weitere Parameter angeben, wird nach dem Kompilieren automatisch gelinkt. Der zweite Aufruf entfällt somit.

Einige Informationen zu Compilern und Linkern finden Sie übrigens im Kapitel Compiler

[Bearbeiten] Namenskonventionen

Übliche Dateiendungen für C++-Quelltexte sind „.cpp“ oder „.cc“. Headerdateien haben oft die Endungen „.hpp“, „.hh“ und „.h“. Letztere ist allerdings auch die gebräuchlichste Dateiendung für C-Header, weshalb zugunsten besserer Differenzierung empfohlen wird, diese nicht zu benutzen.

Die Standardheader von C++ haben überhaupt keine Dateiendung, wie Sie vielleicht schon anhand der beiden Headerdateien iostream und string erraten haben. In der Anfangszeit von C++ endeten Sie noch auf „.h“, inzwischen ist diese Notation aber nicht mehr gültig, obwohl sie immer noch von vielen Compilern unterstützt wird. Der Unterschied zwischen „iostream“ und „iostream.h“ besteht darin, dass in ersterer Headerdatei alle Deklarationen im Standardnamespace std vorgenommen werden.

Prinzipiell kommt es nicht darauf an, welche Dateiendungen Sie ihren Dateien geben, dennoch ist es sinnvoll, eine übliche Endung zu verwenden, wenn auch nur, um einer möglichen Verwechslungsgefahr vorzubeugen. Wenn Sie sich einmal für eine Dateiendung entschieden haben, ist es vorteilhaft, darin eine gewisse Konstanz zu bewahren, nicht nur vielleicht aus Gemütlichkeit und Zeiteinsparnis, sondern auch im Sinne des schnellen Wiederfindens. Einige Beispiele für Headerdateiendungen finden Sie, wenn Sie sich einfach mal einige weitverbreite C++-Bibliotheken ansehen. Boost verwendet „.hpp“, wxWidgets nutzt „.h“ und Qt orientiert sich an der Standardbibliothek, hat also gar keine Dateiendung.

[Bearbeiten] Schutz vor Mehrfacheinbindung

Da Headerdateien oft andere Headerdateien einbinden, kann es leicht passieren, dass eine Headerdatei mehrfach eingebunden wird. Da viele Header nicht nur Deklarationen, sondern auch Definitionen enthalten, führt dies zu Compiler-Fehlermeldungen, da innerhalb einer Übersetzungseinheit ein Name stets nur genau einmal definiert werden darf (mehrfache Deklarationen, die keine Definitionen sind, sind jedoch erlaubt). Um dies zu vermeiden, wird der Präprozessor verwendet. Am Anfang der Headerdatei wird ein Präprozessor-ifndef ausgeführt, das prüft, ob ein Symbol nicht definiert wurde, ist dies der Fall, wird das Symbol definiert. Am Ende der Headerdatei wird die Abfrage mit einem Präprozessor-endif wieder beendet.

mal2.hpp

#ifndef _mal2_hpp_
#define _mal2_hpp_

int mal2(int wert);

#endif

Als Symbol wird üblicherweise aus dem Dateinamen des Headers abgeleitet. In diesem Fall wurde der Punkt durch einen Unterstrich ersetzt und ein weiter Unterstrich vor und nach dem Dateinamen eingefügt. Wenn der Präprozessor nun die Anweisung bekommt, diese Datei in eine andere einzubinden, wird er das anstandslos tun. Findet er eine zweite Anweisung, die Datei einzubinden, wird er alles von #ifndef bis #endif überspringen, da das Symbol _mal2_hpp_ ja nun bereits definiert wurde.

Tipp

Mehr Informationen über Präprozessor-Anweisungen finden Sie im Kapitel Vorarbeiter des Compilers

[Bearbeiten] Inline-Funktionen

Im Kapitel „Prozeduren und Funktionen“ haben Sie bereits erfahren was eine Inline-Funktion ist. Das Schlüsselwort inline empfiehlt dem Compiler, beim Aufruf einer Funktion den Funktionsrumpf direkt durch den Funktionsaufruf zu ersetzen, wodurch bei kurzen Funktionen die Ausführungsgeschwindigkeit gesteigert werden kann. Es bewirkt aber noch mehr. Normalerweise darf eine Definition immer nur einmal gemacht werden. Da für das Inlinen einer Funktion aber die Definition bekannt sein muss, gibt es für Inline-Funktionen eine Ausnahme: Sie dürfen beliebig oft definiert werden, solange alle Definitionen identisch sind. Deshalb dürfen (und sollten) Inline-Funktionen in den Headerdateien definiert werden, ohne dass sich der Linker später über eine mehrfache Definition in verschiedenen Objektdateien beschweren wird.

Hinweis

Inline-Funktionen dürfen auch in cpp-Dateien definiert werden. Allerdings können sie dann auch nur innerhalb der Objektdatei, die aus der cpp-Datei erzeugt wird, geinlinet werden und das ist in aller Regel nicht beabsichtigt.

Zusammenfassung

	Zu diesem Abschnitt existiert leider noch keine Zusammenfassung…
	Wenn Sie Lust haben können Sie die Zusammenfassung zum Abschnitt Weitere Grundelemente selbst schreiben oder einen Beitrag dazu leisten.

Inhaltsverzeichnis Zurück zu Einführung in C++ Weiter zu Eigene Datentypen definieren