Jürgen Wolf. C++ von A bis Z. Das umfassende Handbuch

Transkript

1 Jürgen Wolf C++ von A bis Z Das umfassende Handbuch

2 Auf einen Blick Vorwort Vorwort des Fachgutachters Grundlagen in C Höhere und fortgeschrittene Datentypen Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen Objektorientierte Programmierung Templates und STL Exception-Handling C++-Standardbibliothek Weiteres zum C++-Guru Netzwerkprogrammierung und Cross-Plattform- Entwicklung in C GUI- und Multimediaprogrammierung in C Anhang Index

3 Inhalt Vorwort Vorwort des Fachgutachters Grundlagen in C Die Entstehung von C Aufbau von C Erste Schritte der C++-Programmierung Ein Programm erzeugen mit einem Kommandozeilen-Compiler Ausführen des Programms Ein Programm erzeugen mit einer IDE Symbole von C Bezeichner Schlüsselwörter Literale Einfache Begrenzer Basisdatentypen Deklaration und Definition Was ist eine Variable? Der Datentyp bool Der Datentyp char Die Datentypen int Gleitkommazahlen float, double und long double Limits für Ganzzahl- und Gleitpunktdatentypen Konstanten Standard Ein-/Ausgabe-Streams Die neuen Streams cout, cin, cerr, clog Ausgabe mit cout Ausgabe mit cerr Eingabe mit cin Operatoren Arithmetische Operatoren Inkrement- und Dekrementoperator Bitoperatoren Weitere Operatoren Kommentare

4 Inhalt 1.9 Kontrollstrukturen Verzweigungen (Selektionen) Schleifen (Iterationen) Sprunganweisungen Funktionen Deklaration und Definition Funktionsaufruf und Parameterübergabe Lokale und globale Variablen Standardparameter Funktionen überladen Inline-Funktionen Rekursionen main-funktion Präprozessor-Direktiven Die #define-direktive Die #undef-direktive Die #include-direktive Die Direktiven #error und #pragma Bedingte Kompilierung Höhere und fortgeschrittene Datentypen Zeiger Zeiger deklarieren Adresse im Zeiger speichern Zeiger dereferenzieren Zeiger, die auf andere Zeiger verweisen Dynamisch Speicherobjekte anlegen und zerstören new und delete void-zeiger Konstante Zeiger Referenzen Arrays Arrays deklarieren Arrays initialisieren Bereichsüberschreitung von Arrays Anzahl der Elemente eines Arrays ermitteln Arraywert von Tastatur einlesen Mehrdimensionale Arrays Zeichenketten (C-Strings) char-array C-String deklarieren und initialisieren

5 Inhalt C-String einlesen C-Strings Bibliotheksfunktionen Arrays und Zeiger C-Strings und Zeiger Mehrfache Indirektion C-String-Tabellen Arrays im Heap (Dynamisches Array) Parameterübergabe mit Zeigern, Arrays und Referenzen Call by value Call by reference Zeiger als Funktionsparameter Call by reference mit Referenzen nachbilden Arrays als Funktionsparameter Mehrdimensionale Arrays an Funktionen übergeben Argumente an die main-funktion übergeben Rückgabewerte von Zeiger, Arrays und Referenzen Zeiger als Rückgabewert Referenz als Rückgabewert const-zeiger als Rückgabewert Array als Rückgabewert Mehrere Rückgabewerte Fortgeschrittene Typen Strukturen Unions Aufzählungstypen typedef Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen Gültigkeitsbereiche (Scope) Lokaler Gültigkeitsbereich (Local Scope) Gültigkeitsbereich Funktionen Gültigkeitsbereich Namensraum (Namespaces) Gültigkeitsbereich Klassen (Class Scope) Namensräume (Namespaces) Neuen Namensbereich erzeugen (Definition) Zugriff auf die Bezeichner im Namensraum using einzelne Bezeichner aus einem Namensraum importieren using alle Bezeichner aus einem Namensraum importieren

6 Inhalt Namensauflösung Aliasnamen für Namensbereiche Anonyme (namenlose) Namensbereiche Namensbereich und Headerdateien C-Funktionen bzw. Bibliotheken in einem C++-Programm C-Funktionen aus einer C-Bibliothek aufrufen Speicherklassenattribute Speicherklasse auto Speicherklasse register Speicherklasse static Speicherklasse extern Speicherklasse mutable Typenqualifikatoren Qualifizierer const Qualifizierer volatile Funktionsattribute Typumwandlung Standard-Typumwandlung Explizite Typumwandlung Objektorientierte Programmierung OOP-Konzept versus prozedurales Konzept OOP-Paradigmen Klassen (fortgeschrittene Typen) Klassen deklarieren Elementfunktion (Klassenmethode) definieren Objekte deklarieren Kurze Zusammenfassung private und public Zugriffsrechte in der Klasse Zugriff auf die Elemente (Member) einer Klasse Ein Programm organisieren Konstruktoren Destruktoren Mehr zu den Klassenmethoden (Klassenfunktionen) Inline-Methoden (explizit und implizit) Zugriffsmethoden Read-only-Methoden this-zeiger Verwenden von Objekten Read-only-Objekte

7 Inhalt Objekte als Funktionsargumente Objekte als Rückgabewert Klassen-Array (Array von Objekten) Dynamische Objekte Dynamische Klassenelemente Objekte kopieren (Kopierkonstruktor) Dynamisch erzeugte Objekte kopieren (operator=()) Standardmethoden (Überblick) Objekte als Elemente (bzw. Eigenschaften) in anderen Klassen Teilobjekte initialisieren Klassen in Klassen verschachteln Konstante Klasseneigenschaften (Datenelemente) Statische Klasseneigenschaften (Datenelemente) Statische Klassenmethoden friend-funktionen bzw. friend-klassen Zeiger auf Eigenschaften einer Klasse Operatoren überladen Grundlegendes zur Operator-Überladung Überladen von arithmetischen Operatoren Überladen von unären Operatoren Überladen von ++ und Überladen des Zuweisungsoperators Überladen des Indexoperators [ ] (Arrays überladen) Shift-Operatoren überladen ( )-Operator überladen new- und delete-operator überladen Typenumwandlung für Klassen Konvertierungskonstruktor Konvertierungsfunktion Vererbung (Abgeleitete Klassen) Anwendungsbeispiel (die Vorbereitung) Die Ableitung einer Klasse Redefinition von Klassenelementen Konstruktoren Destruktoren Zugriffsrecht protected Typenumwandlung abgeleiteter Klassen Klassenbibliotheken erweitern

8 Inhalt 4.8 Polymorphismus Statische bzw. dynamische Bindung Virtuelle Methoden Virtuelle Methoden redefinieren Arbeitsweise von virtuellen Methoden Virtuelle Destruktoren bzw. Destruktoren abgeleiteter Klassen Polymorphismus und der Zuweisungsoperator Rein virtuelle Methoden und abstrakte Basisklassen Probleme mit der Vererbung und der dynamic_cast-operator Fallbeispiel: Verkettete Listen Mehrfachvererbung Indirekte Basisklassen erben Virtuelle indirekte Basisklassen erben Templates und STL Funktions-Templates Funktions-Templates definieren Typenübereinstimmung Funktions-Templates über mehrere Module Spezialisierung von Funktions-Templates Verschiedene Parameter Explizite Template-Argumente Klassen-Templates Definition Methoden von Klassen-Templates definieren Klassen-Template generieren (Instantiierung) Weitere Template-Parameter Standardargumente von Templates Explizite Instantiierung STL (Standard Template Library) Konzept von STL Hilfsmittel (Hilfsstrukturen) Allokator Iteratoren Container Algorithmen Allokatoren

9 Inhalt 6 Exception-Handling Exception-Handling in C Eine Exception auslösen Eine Exception auffangen Handle einrichten Reihenfolge (Auflösung) der Ausnahmen Alternatives catch(...) Stack-Abwicklung (Stack-Unwinding) try-blöcke verschachteln Exception weitergeben Ausnahme-Klassen (Fehlerklassen) Klassenspezifische Exceptions Standard-Exceptions Virtuelle Methode what() Anwenden der Standard-Exceptions System-Exceptions bad_alloc bad_cast bad_typeid bad_exception Exception-Spezifikation Unerlaubte Exceptions terminate-handle einrichten C++-Standardbibliothek Die String-Bibliothek (string-klasse) Exception-Handling Datentypen Strings erzeugen (Konstruktoren) Zuweisungen Elementzugriff Länge und Kapazität ermitteln bzw. ändern Konvertieren in einen C-String Manipulation von Strings Suchen in Strings Strings vergleichen Die (überladenen) Operatoren Einlesen einer ganzen Zeile Ein-/Ausgabe Klassenhierarchie (I/O-Streams) Klassen für Ein- und Ausgabe-Streams

10 Inhalt Klassen für Datei-Streams (File-Streams) Klassen für String-Streams Die Klasse streambuf Die Klasse filebuf Die Klasse stringbuf Die Klasse stdiobuf Numerische Bibliothek(en) Komplexe Zahlen (complex-klasse) valarray Globale numerische Funktionen (cmath und cstdlib) Grenzwerte von Zahlentypen Halbnumerische Algorithmen Typenerkennung zur Laufzeit Weiteres zum C++-Guru Module Aufteilung Die öffentliche Schnittstelle (Headerdatei) Die private Datei Die Client-Datei Speicherklassen extern und static Werkzeuge Von C zu C Notizen Kein C Kein C malloc und free oder new und delete setjmp und longjmp oder catch und throw »Altes«C Headerdateien mit und ohne Endung Standardbibliothek nicht komplett oder veraltet Namespace (Namensbereiche) Schleifenvariable von for UML Wozu UML? UML-Komponenten Diagramme erstellen Klassendiagramme mit UML Programmierstil Kommentare

11 Inhalt Code Benennung Codeformatierung Zusammenfassung Boost Boost.Regex (Reguläre Ausdrücke) Netzwerkprogrammierung und Cross-Plattform- Entwicklung in C Begriffe zur Netzwerktechnik IP-Nummern Portnummer Host- und Domainname Nameserver Das IP-Protokoll TCP und UDP Was sind Sockets? Headerdateien zur Socketprogrammierung Linux/UNIX Windows Client-/Server-Prinzip Loopback-Interface Erstellen einer Client-Anwendung socket() Erzeugen eines Kommunikationsendpunkts connect() Client stellt Verbindung zum Server her Senden und Empfangen von Daten close(), closesocket() Erstellen einer Server-Anwendung bind() Festlegen einer Adresse aus dem Namensraum listen() Warteschlange für eingehende Verbindungen einrichten accept() und die Server-Hauptschleife Cross-Plattform-Development Abstraktion Layer Headerdatei (socket.h) Quelldatei (socket.cpp) TCP-Echo-Server (Beispiel) Exception-Handling integrieren Server- und Client-Sockets erstellen (TCP)

12 Inhalt Ein UDP-Beispiel Mehrere Clients gleichzeitig behandeln Weitere Anmerkungen zur Netzwerkprogrammierung Das Datenformat Der Puffer Portabilität Von IPv4 nach IPv RFC-Dokumente (Request for Comments) Sicherheit Fertige Bibliotheken GUI- und Multimediaprogrammierung in C GUI-Programmierung Überblick Low-Level High-Level Überblick zu plattformunabhängigen Bibliotheken Überblick zu plattformabhängigen Bibliotheken Multimedia- und Grafikprogrammierung Überblick Überblick zu plattformunabhängigen Bibliotheken Überblick zu plattformabhängigen Bibliotheken GUI-Programmierung mit wxwidgets Warum wxwidgets? Das erste Programm Hallo Welt Die grundlegende Struktur eines wxwidgets-programm Event-Handle (Ereignisse behandeln) Die Fenster-Grundlagen Übersicht zu den wxwidgets-(fenster-)klassen wxwindow, wxcontrol und wxcontrolwithitems Die Basisklassen Top-Level-Fenster Container Fenster Nicht statische Kontroll-Elemente Statische Kontroll-Elemente Menüs Ein Beispiel Text-Editor Standarddialoge Weitere Elemente und Techniken im Überblick

13 Inhalt 11 Anhang Operatoren in C++ und deren Bedeutung (Übersicht) Vorrangtabelle der Operatoren Schlüsselwörter von C Informationsspeicherung Zahlensysteme Zeichensätze ASCII-Zeichensatz ASCII-Erweiterungen Unicode Index

14 Das Kapitel behandelt Themen, die zwar recht trocken und sehr theoretisch, aber für die Praxis unverzichtbar sind. In den ersten beiden Kapiteln haben Sie viel über verschiedene Datentypen (Basistypen, Zeiger, Referenzen, strukturierte Typen etc.) und Funktionen erfahren. In diesem Zusammenhang wurden aber noch einige wichtige Aspekte vernachlässigt, und zwar die Gültigkeitsbereiche, Namensräume und die Sichtbarkeit. Auch die Deklarationen wurden nur recht einfach erklärt. Hierbei gibt es aber noch besondere Speicherklassenattribute, Typenqualifikatoren und Funktionsattribute. Und dann fehlen noch die Typumwandlungen, bei denen man zwischen einer Standard-Umwandlung und einer expliziten Umwandlung unterscheidet. 3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen 3.1 Gültigkeitsbereiche (Scope) Zunächst sollte man nicht den Fehler machen, den Begriff»Gültigkeitsbereich«mit dem Begriff»Sichtbarkeit«gleichzusetzen. Ein Speicherobjekt ist sichtbar, wenn man innerhalb eines Bereichs darauf zugreifen kann. Damit ein solches Objekt sichtbar ist, muss es gültig sein. Sie können zum Beispiel ein Objekt»ungültig«machen, indem Sie es mit einem Objekt mit gleichem Namen überdecken: // cu.cpp #include <iostream> using namespace std; int main(void) { // iwert ist hier "Sichtbar" int iwert = 100; { // iwert überdeckt das äußere iwert int iwert = 200; cout << iwert << '\n'; 219

15 3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen // hier ist inneres iwert nicht mehr gültig // und somit ist äußeres iwert wieder Sichtbar cout << iwert << '\n'; return 0; Das Programm bei der Ausführung: Jetzt aber zum eigentlichen Thema, den Gültigkeitsbereichen in C++. Der Gültigkeitsbereich ist ein Abschnitt im Quellcode, wo ein deklarierter Bezeichner verwendet werden kann. Häufig wird auch von einem»scope«(=gültigkeitsbereich des Bezeichners) gesprochen Lokaler Gültigkeitsbereich (Local Scope) Wenn Sie einen Anweisungsblock verwenden, haben Sie automatisch einen lokalen Gültigkeitsbereich (Local Scope) eingeführt. In einem lokalen Gültigkeitsbereich gelten die dort deklarierten Bezeichner immer nur im Anweisungsblock (zwischen den geschweiften Klammern). Hierzu gehören alle Arten von Kontrollstrukturen wie if, for, switch und while, die auch als»substatement Scope«bezeichnet werden. Wenn mehrere gleichnamige Variablen vorhanden sind, erhält immer die lokalste Variable den Zuschlag. Eine Ausnahme bildet die Verwendung des Scope-Operators (oder auch Bereichsoperator) :: aber dazu in Kürze mehr. { int iwert = 100; { // Verwendet äußeres iwert cout << iwert << '\n'; int iwert = 200; // Verwendet inneres iwert cout << iwert << '\n'; Gültigkeitsbereich Funktionen Der Gültigkeitsbereich eines Funktionsprototypen gilt bis zum Ende der Deklaration (mitsamt Funktionsparameter), und der Gültigkeitsbereich der Funktionsdefinition erstreckt sich über die gesamte Funktion (also dem Anweisungsblock der Funktion). Ansonsten gilt auch hier, dass bei der Verwendung einer globalen 220

16 Gültigkeitsbereiche (Scope) 3.1 und einer lokalen Variable mit demselben Namen, die lokalste Variable den Zuschlag erhält. Eine Ausnahme gibt es jedoch wieder, wenn Sie den Scope-Operator :: verwenden. Mit dem Scope-Operator haben Sie die Möglichkeit, auf den globalen Gültigkeitsbereich zuzugreifen (egal von wo). Haben Sie zum Beispiel eine lokale und globale Variable mit dem Namen»iwert«, können Sie mit»::iwert«auf den globalen und wie immer mit»iwert«(ohne den Scope-Operator) auf das lokale Objekt zugreifen. Dieser Operator wird noch näher im Kapitel 4 bei den Klassen besprochen. Trotzdem hierzu ein Beispiel: // scope.cpp #include <iostream> using namespace std; // globale Variable int iwert = 11; void func( void ); int main(void) { func(); return 0; void func( void ) { int iwert = 22; // iwert der Funktion erhält Zuschlag cout << iwert << '\n'; { // Nochmals iwert der Funktion cout << iwert << '\n'; int iwert = 33; // Inneres iwert erhält Zuschlag cout << iwert << '\n'; // Globales iwert erhält den Zuschlag cout << ::iwert << '\n'; // nochmals globales iwert cout << ::iwert << '\n'; Das Programm bei der Ausführung:

17 3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen Gültigkeitsbereich Namensraum (Namespaces) Ein Bezeichner, der in einem Namensraum deklariert ist, existiert vom Anfang seiner Deklaration bis zum Ende des Namensraums. Wegen der Wichtigkeit der Namensräume (englisch: Namespaces) in C++ wird in Abschnitt 3.2 gesondert darauf eingegangen Gültigkeitsbereich Klassen (Class Scope) Klassenelemente, die in einer Klasse deklariert werden, gelten von dieser Deklaration an bis zum Ende der Klassendeklaration. Auf Klassenelemente kann nur in Verbindung mit einer Variablen des Klassentyps zugegriffen werden. Darauf wird speziell bei den Klassen in Kapitel 4 eingegangen. 3.2 Namensräume (Namespaces) Mit Namensräumen (Namespaces) können Sie einen Gültigkeitsbereich erzeugen, in dem Sie beliebige Bezeichner wie Klassen, Funktionen, Variablen, Typen und sogar andere Namensräume deklarieren können. Die Verwendung von Namensräumen ist besonders hilfreich bei sehr umfangreichen Projekten wo für gewöhnlich mit mehreren Modulen und Klassenbibliotheken gearbeitet wird. Hier kann es passieren, dass es bei der Vergabe von Namen zu Konflikten mit gleichen Namen kommt. Zwei Klassen oder Funktionen mit demselben Namen lassen sich zum Beispiel ohne Namensräume nicht verwenden Neuen Namensbereich erzeugen (Definition) Einen neuen Namensbereich können Sie entweder global oder innerhalb eines bereits definierten Namensbereichs einführen. Dieser wird deklariert, indem hinter dem Schlüsselwort namespace der Name des Namensraums folgt. Die Deklarationen, die anschließend zu diesem Namensbereich gehören, werden zwischen geschweiften Klammern angegeben: namespace meinbereich { int iwert; float fwert; // Definition von funktion() void funktion ( void ) { 222

18 Namensräume (Namespaces) 3.2 // Anweisungen von funktion() // Definition von eineklasse class eineklasse { // Anweisungen für eineklasse Hier haben Sie eine int-variable»iwert«, eine float-variable»fwert«, die Funktion»funktion«und die Klasse»eineKlasse«als Elemente für den Namensbereich»meinBereich«deklariert. Natürlich können Sie einen solchen Namensbereich jederzeit um weitere Elemente erweitern. Im Beispiel wurde die Funktion»funktion«und die Klasse»eineKlasse«bereits definiert. In der Praxis wird allerdings meistens eine Deklaration im Namensbereich gemacht. Die eigentliche Definition wird für gewöhnlich außerhalb des Namensbereichs durchgeführt. Hierzu muss allerdings der Namensbereich mit dem Scope-Operator (bzw. Bereichsoperator) verwendet werden. Die Funktion»funktion«und die Klasse»meineKlasse«wird dann wie folgt definiert: namespace meinbereich { int iwert; float fwert; // Deklaration von funktion() void funktion ( void ); // Deklaration von eineklasse class eineklasse; // Definition von funktion() void meinbereich::funktion( void ) { // Anweisungen von funktion() // Definition von eineklasse class meinbereich::eineklasse { // Anweisungen für eineklasse Einen bereits eingeführten Namensbereich können Sie außerdem jederzeit wieder öffnen und um weitere Elemente erweitern oder die Definition darin machen. Beispielsweise: namespace meinbereich { int iwert; 223

19 3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen float fwert; // Deklaration von funktion() void funktion ( void ); // Deklaration von eineklasse class eineklasse; // Erneut im Namensbereich meinbereich namespace meinbereich { // Definition von meinbereich::funktion( void ) void funktion( void ) { // Anweisungen von funktion() // Definition von eineklasse class meinbereich::eineklasse { // Anweisungen für eineklasse // Namensbereich neu öffnen und erweitern namespace meinbereich { // Namensbereich meinbereich um dwert erweitert double dwert; Jetzt könnten Sie theoretisch einen neuen Namensbereich mit denselben Funktionen erzeugen, ohne dass es hierbei zu Konflikten kommt: namespace meinbereich { int iwert; float fwert; // Deklaration von funktion() void funktion ( void ); // Deklaration von eineklasse class eineklasse; namespace mein_neuer_bereich { int iwert; float fwert; // Deklaration von funktion() void funktion ( void ); // Deklaration von eineklasse class eineklasse; 224

20 Namensräume (Namespaces) 3.2 Hier haben Sie zwei Namensbereiche (»meinbereich«und»mein_neuer_ Bereich«) mit denselben Elementen. Das kommt zwar in der Praxis selten in dieser Form vor, soll aber hier demonstrieren, wofür Namensbereiche dienen Zugriff auf die Bezeichner im Namensraum Verwenden Sie einen Bezeichner innerhalb eines Namensraums, so können Sie diesen, wie gewöhnlich, über den Typ und den Bezeichner ansprechen. Bezeichner; Wollen Sie allerdings einen Bezeichner außerhalb des Namensbereichs verwenden, müssen Sie den Namensbereich mit dem Scope-Operator mitangeben. Namensbereich::Bezeichner; Auf globale Bezeichner, die Sie außerhalb eines Namensbereichs definiert haben, können Sie mit dem Scope-Operator (Bereichsoperator) alleine zugreifen. // Aufruf von globalen Bezeichner ::Bezeichner; Hierzu ein Beispiel, das die Zugriffe auf die einzelnen Bezeichner eines Namensraums demonstrieren soll. Im Beispiel wurde dreimal eine Funktion»funktion()«und dreimal der Wert»iwert«verwendet, ohne dass es zu Konflikten kommt. // namespace1.cpp #include <iostream> using namespace std; // Deklaration globale Funktion void funktion( void ); // globale Variable iwert int iwert = 1; namespace ersterbereich { int iwert = 11; // Deklaration von Funktion im // Namensbereich ersterbereich void funktion( void ); namespace zweiterbereich { int iwert = 22; // Deklaration von Funktion im // Namensbereich zweiterbereich void funktion( void ); 225

21 3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen int main(void) { int gesamt; // Aufruf von funktion() aus Namensbereich ersterbereich ersterbereich::funktion(); // Aufruf von funktion() aus Namensbereich zweiterbereich zweiterbereich::funktion(); // Aufruf der globalen Funktion funktion()... funktion(); //... oder auch ::funktion(); // Zugriff auf den Wert iwert aus ersterbereich ersterbereich::iwert = 66; // Nochmals die Funktion aus dem // Namensbereich ersterbereich ersterbereich::funktion(); // Rechnung mit Werten aus mehreren Namensbereichen gesamt = ersterbereich::iwert + zweiterbereich::iwert + ::iwert; cout << "Summe aus allen Namensbereichen : " << gesamt << '\n'; return 0; // globale Funktion definieren void funktion( void ) { cout << "funktion(): Globale\n"; cout << "Wert von iwert : " << iwert << "\n\n"; void ersterbereich::funktion( void ) { cout << "funktion(): Namensbereich ersterbereich\n"; cout << "Wert von iwert : " << iwert << "\n\n"; void zweiterbereich::funktion( void ) { cout << "funktion(): Namensbereich zweiterbereich\n"; cout << "Wert von iwert : " << iwert << "\n\n"; 226

22 Namensräume (Namespaces) 3.2 Das Programm bei der Ausführung: funktion(): Namensbereich ersterbereich Wert von iwert : 11 funktion(): Namensbereich zweiterbereich Wert von iwert : 22 funktion(): Globale Wert von iwert : 1 funktion(): Globale Wert von iwert : 1 funktion(): Namensbereich ersterbereich Wert von iwert : 66 Summe aus allen Namensbereichen : 89 Die Verwendung der globalen Funktion aus der main-funktion heraus kann auch ohne de Scope-Operator verwendet werden. Wollen Sie aber zum Beispiel die globale Funktion»funktion()«aus einem anderen Namensbereich aufrufen, benötigen Sie wieder den Scope-Operator. Wenn aus dem Namensbereich»ersterBereich«die globale Funktion»funktion()«verwendet werden soll, müssen Sie wie folgt vorgehen: void ersterbereich::funktion( void ) { cout << "funktion(): Namensbereich ersterbereich\n"; cout << "Wert von iwert : " << iwert << "\n\n"; // Ruft die globale Funktion funktion() auf ::funktion(); Den Scope-Operator zu vergessen, hätte in diesem Beispiel außerdem noch den negativen Effekt, dass eine nicht mehr ohne Gewalt zu beendende Rekursion gestartet würde. In der Praxis sollte man es sich angewöhnen, den Scope-Operator zu verwenden. Werden (wie im Beispiel gesehen) mehrere Funktionen mit demselben Namen deklariert sowie definiert, und Sie importieren einzelne oder alle Bezeichner aus einem Namensbereich, so wird dem Bezeichner aus dem importierten Bereich der Vorzug gegeben, da dieser dann eben der globalere Bezeichner ist (siehe auch den nächsten Abschnitt 3.2.3). 227

23 3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen using einzelne Bezeichner aus einem Namensraum importieren Will man nicht ständig den Namensbereich mitangeben, kann man auch einzelne Bezeichner aus einem Namensbereich»importieren«. Hierzu werden Deklarationen mit dem Schlüsselwort using gemacht. Mit folgender using-deklaration können Sie zum Beispiel aus dem Namensbereich»ersterBereich«die Funktion»funktion()«importieren: using ersterbereich::funktion; // Achtung, ohne Klammern () Jetzt können Sie die Funktion»funktion()«aus dem Namensbereich»erster- Bereich«mit einem einfachen Aufruf des Bezeichners aufrufen: funktion(); // Funktion aus Namensbereich ersterbereich Hierzu nochmals unser Beispiel»namespace1.cpp«, verändert mit dem Schlüsselwort using und einigen importierten Bezeichnern: // namespace2.cpp #include <iostream> using namespace std; // Deklaration globale Funktion void funktion( void ); // globale Variable iwert int iwert = 1; namespace ersterbereich { int iwert = 11; // Deklaration von Funktion // im Namensbereich ersterbereich void funktion( void ); namespace zweiterbereich { int iwert = 22; // Deklaration von Funktion // im Namensbereich zweiterbereich void funktion( void ); int main(void) { using ersterbereich::funktion; using zweiterbereich::iwert; int gesamt; 228

24 Namensräume (Namespaces) 3.2 // Aufruf von funktion() aus Namensbereich ersterbereich funktion(); // Aufruf von funktion() aus Namensbereich zweiterbereich zweiterbereich::funktion(); // Aufruf der globalen Funktion funktion()... // Jetzt unbedingt mit dem Scope-Operator :: ::funktion(); // Zugriff auf den Wert iwert aus zweiterbereich iwert = 66; // Nochmals die Funktion aus dem // Namensbereich zweiterbereich zweiterbereich::funktion(); // Rechnung mit Werten aus mehreren Namensbereichen gesamt = ersterbereich::iwert + iwert + ::iwert; cout << "Summe aus allen Namensbereichen : " << gesamt << '\n'; return 0; // globale Funktion definieren void funktion( void ) { cout << "funktion(): Globale\n"; cout << "Wert von iwert : " << iwert << "\n\n"; void ersterbereich::funktion( void ) { cout << "funktion(): Namensbereich ersterbereich\n"; cout << "Wert von iwert : " << iwert << "\n\n"; void zweiterbereich::funktion( void ) { cout << "funktion(): Namensbereich zweiterbereich\n"; cout << "Wert von iwert : " << iwert << "\n\n"; Das Programm bei der Ausführung: funktion(): Namensbereich ersterbereich Wert von iwert : 11 funktion(): Namensbereich zweiterbereich Wert von iwert :

25 3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen funktion(): Namensbereich ersterbereich Wert von iwert : 11 funktion(): Namensbereich zweiterbereich Wert von iwert : 66 Summe aus allen Namensbereichen : 78 Hinweis Eine using-deklaration ist die Deklaration eines Namens im Gültigkeitsbereich und keine Definition! using alle Bezeichner aus einem Namensraum importieren Wollen Sie alle Bezeichner eines Namensraums sichtbar machen, so ist dies zum Beispiel mit folgender Angabe möglich: using namespace ersterbereich; Jetzt sind alle Bezeichner aus dem Namensbereich»ersterBereich«einfach mit dem Bezeichner ansprechbar es ist keine explizite Angabe des Scope-Operators mehr nötig. Natürlich kann es trotzdem sinnvoll sein, den Scope-Operator zu verwenden, um Mehrdeutigkeiten zu vermeiden. Beachten Sie bitte, dass eine using-direktive, die den kompletten Namensbereich»importiert«, nicht einer Deklaration aller Namen eines Namensbereichs entspricht, sondern lediglich einer Bekanntgabe des Namensraums. Dies bedeutet, dass eine using-direktive alleine noch nicht zu einem Konflikt führt, wenn sich im aktuellen und importierten Namensbereich gleiche Bezeichner befinden. Das Problem der Mehrdeutigkeit tritt erst dann auf, wenn die Bezeichner angesprochen werden. Dazu sollte man wissen, wie C++ nach einem Bezeichner sucht (siehe Abschnitt 3.2.5, Namensauflösung). Hinweis Beim»Importieren«einzelner Bezeichner aus einem Namensraum spricht man von einer using-deklaration. Bei der Verwendung aller Namen aus dem Namensraum ohne Angabe des Scope-Operators wird von einer using-direktiven gesprochen. Ein Beispiel, das die Verwendung von using-direktiven demonstriert: // namespace3.cpp #include <iostream> using namespace std; namespace ersterbereich { int iwert = 11; // Deklaration von Funktion funktion1 230

26 Namensräume (Namespaces) 3.2 // im Namensbereich ersterbereich void funktion1( void ); namespace zweiterbereich { float fwert = 11.11; // Deklaration von Funktion funktion2 // im Namensbereich zweiterbereich void funktion2( void ); int main(void) { using namespace ersterbereich; using namespace zweiterbereich; // Ruft funktion1() aus Namensbereich ersterbereich auf funktion1(); // Ruft funktion2() aus Namensbereich zweiterbereich auf funktion2(); // Gibt den Wert von iwert aus Bereich ersterbereich aus cout << "main() -> iwert : " << iwert << '\n'; // Gibt den Wert von fwert aus Bereich zweiterbereich aus cout << "main() -> fwert : " << fwert << '\n'; return 0; void ersterbereich::funktion1( void ) { cout << "funktion(): Namensbereich ersterbereich\n"; cout << "Wert von iwert : " << iwert << "\n\n"; void zweiterbereich::funktion2( void ) { cout << "funktion(): Namensbereich zweiterbereich\n"; cout << "Wert von fwert : " << fwert << "\n\n"; Das Programm bei der Ausführung: funktion(): Namensbereich ersterbereich Wert von iwert : 11 funktion(): Namensbereich zweiterbereich Wert von fwert :

27 3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen main() -> iwert : 11 main() -> fwert : Wenn ein Namensraum auch eine using-direktive enthält, die Bezeichner importiert, so wird automatisch der zweite Namensbereich mit importiert: // namespace4.cpp #include <iostream> using namespace std; namespace ersterbereich { int iwert = 11; // Deklaration von Funktion funktion1 // im Namensbereich ersterbereich void funktion1( void ); namespace zweiterbereich { using namespace ersterbereich; float fwert = 11.11; // Deklaration von Funktion funktion2 // im Namensbereich zweiterbereich void funktion2( void ); int main(void) { // Importiert automatisch auch ersterbereich using namespace zweiterbereich; // Ruft funktion1() aus Namensbereich ersterbereich auf funktion1(); // Ruft funktion2() aus Namensbereich zweiterbereich auf funktion2(); // Gibt den Wert von iwert aus Bereich ersterbereich aus cout << "main() -> iwert : " << iwert << '\n'; // Gibt den Wert von fwert aus Bereich zweiterbereich aus cout << "main() -> fwert : " << fwert << '\n'; return 0; void ersterbereich::funktion1( void ) { cout << "funktion(): Namensbereich ersterbereich\n"; cout << "Wert von iwert : " << iwert << "\n\n"; 232

28 Namensräume (Namespaces) 3.2 void zweiterbereich::funktion2( void ) { cout << "funktion(): Namensbereich zweiterbereich\n"; cout << "Wert von fwert : " << fwert << "\n\n"; Sie können die Namensbereiche aber auch verschachteln, das heißt in einem Namensbereich können noch mehrere andere Namensbereiche deklariert werden. Hier ein solches Beispiel: namespace ersterbereich_aussen { int iwert = 11; void funktion( void ); namespace ersterbereich_innen1 { int iwert = 22; void funktion1( void ); namespace ersterbereich_innen2 { int iwert = 33; void funktion2( void );... // Aufruf von funktion1() ersterbereich_aussen::ersterbereich_innen1::funktion1(); // Aufruf von funktion2() ersterbereich_aussen::ersterbereich_innen2::funktion2(); // Aufruf von funktion() ersterbereich_aussen::funktion(); Wenn Sie Namensbereiche verschachteln, kann dies sehr verwirrend, daher sollten Sie sich folgende Zugriffsregeln merken: Ein Bezeichner im inneren Namensraum verdeckt Bezeichner gleichen Namens aus den äußeren Bereichen. Im inneren Namensraum können Sie die Bezeichner aus den äußeren Namensbreichen verwenden, ohne den Scope-Operator dafür zu benutzen. Alle Bezeichner eines inneren Namensraums sind für den äußeren Namensbreich nicht sichtbar und müssen mit dem Scope-Operator verwendet werden. Bei verschachtelten Namensräumen, die mit der using-direktive»importiert«werden, sind nur die Bezeichner im Namensraum selbst sichtbar! Bezeichner innerhalb eines Namensraums sind hier noch nicht verfügbar. 233

29 3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen Namensauflösung Hier der versprochene Abschnitt, der kurz beschreibt, wie C++ nach einem Bezeichner sucht (wird auch als Name Lookup bezeichnet). Hier ein Beispiel, mit dem Sie die anschließend beschriebenen Namensauflösungen in der Praxis demonstrieren können, indem Sie die einzelnen Bezeichner»iwert«auskommentieren bzw. wieder anwenden. // namespace5.cpp #include <iostream> using namespace std; namespace einbereich { // Deklaration im Namensbereich einbereich int iwert = 11; // globale Deklaration int iwert = 22; int main(void) { using namespace einbereich; // lokale Deklaration int iwert = 33; cout << iwert << '\n'; return 0; Stößt der Compiler auf einen Bezeichner, versucht er diesen Namen nach folgendem Schema aufzulösen: Zuerst wird nach der lokalen Deklaration eines Bezeichners gesucht. Wird keine lokale Deklaration des Bezeichners gefunden, werden Bereiche abgesucht, die im aktuellen Gültigkeitsbereich enthalten sind. Dies umfasst theoretisch auch den globalen Bereich. Als letztes wird nach dem Bezeichner im importieren Namensraum gesucht. Dies beinhaltet auch die namenlosen Namensbereiche (siehe Abschnitt 3.2.7) Aliasnamen für Namensbereiche Wenn ein Namensbereich bereits definiert wurde, dürfen Sie dafür auch einen neuen Namen (genauer Aliasname) verwenden. namespace neuername altername; 234

30 Namensräume (Namespaces) 3.2 Hiermit können Sie auf die Bezeichner des Namensbereichs sowohl mit»neuer- Name«als auch mit»altername«zugreifen. Diese Technik wird gerne beim Zugriff auf verschachtelte Namensbereiche verwendet. Beispielsweise: namespace ersterbereich_aussen { int iwert = 11; void funktion( void ); namespace ersterbereich_innen { float fwert = 11.11; void funktion1( void ); Wenn Sie nun folgende Definition machen namespace einbereich ersterbereich::ersterbereich_innen; können Sie zum Beispiel mit einbereich::fwert = 22.22; auf die Variable»fwert«im inneren Bereich des Namensbereichs»ersterBereich_ innen«zugreifen. Ohne den Aliasnamen müssten Sie umständlich Folgendes verwenden: ersterbereich_aussen::erster_bereich_innen::fwert = 22.22; Anonyme (namenlose) Namensbereiche Es kann auch ein Namensraum ohne einen Namen verwendet werden. Beispielsweise: namespace { //... Dieser Namensbereich wird als Namensraum mit einem systemweit eindeutigen Namen mit einer using-direktive verwendet und entspricht im Prinzip folgendem Konstrukt: namespace einbereich { //... using namespace einbereich; Auch wenn Sie dem anonymen Namensbereich keinen Namen gegeben haben, so wird dennoch einer vom Compiler vergeben. Durch die automatische Verwendung der anschließenden using-direktive können Sie Bezeichner eines anony- 235

31 3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen men Namensbereichs im aktuellen Gültigkeitsbereich (siehe Abschnitt 3.1) direkt (ohne Scope-Operator) ansprechen. Außerhalb dieses Gültigkeitsbereichs können die Bezeichner des anonymen Namenbereichs nicht mehr verwendet werden, weil es nicht möglich ist eine using-direktive für einen Namensbereich zu verwenden, der keinen Namen hat. Damit hat man ein effektives Mittel, wenn man globale Variablen verwenden will/muss (warum auch immer). Da der Gültigkeitsbereich nur für die aktuelle Übersetzungseinheit (beispielsweise der Datei) gültig ist, entstehen keine Konflikte, wenn in einer anderen Datei der Übersetzungseinheit eine globale Variable mit demselben Namen existieren sollte. Natürlich stellt dies nach wie vor keinen Freischein für globale Variablen dar. Nebenbei stellen anonyme Namensbereiche eine gute Alternative für static- Deklarationen da. Beispielsweise: static int iwert; Hier haben Sie eine Variable vom Typ int mit einer statischen (siehe Abschnitt 3.4.3) Lebensdauer deklariert. Auch diese Deklaration hat ihren Gültigkeitsbereich in der aktuellen Übersetzungseinheit. Dasselbe realisieren Sie auch mit einem anonymen Namensraum wie folgt: namespace { int iwert; Namensbereich und Headerdateien Das beste Beispiel zum Thema Namensbereich finden Sie in der C++-Standardbibliothek selbst. Im ANSI-C++-Standard sind alle Klassen, Objekte und Funktionen in der C++-Standardbibliothek im Namensbereich std definiert. Durch die Verwendung von using namespace std; im Programm ersparen Sie sich den Scope-Operator und können auf alle Klassen, Objekte und Funktionen ohne den Scope-Operator :: auf die Bezeichner zugreifen. Ohne die Verwendung der using-direktive und das»importieren«des Namensbereichs std müssten Sie auf die Bezeichner der Headerdatei <iostream> wie folgt zugreifen: // namespace6.cpp #include <iostream> 236

32 Namensräume (Namespaces) 3.2 int main(void) { std::cout << "Ohne using namespace std\n"; return 0; Ich könnte es jetzt hierbei belassen und davon ausgehen, dass schon alles in Ordnung gehen wird. Aber wenn Sie sich vielleicht schon einige ältere Quellcodes angesehen haben, werden Sie feststellen, dass es Programme gibt, die iostream folgendermaßen einbinden #include <iostream.h> (also mit».h«) und keine using-direktive für den Namensbereich std verwenden. Wenn Sie also das folgende Programm übersetzen, werden Sie gewöhnlich keine Probleme bekommen: // namespace7.cpp #include <iostream.h> int main(void) { cout << "Ohne using namespace std\n"; return 0; Das dies hier ohne Bekanntgabe des Namensbereichs std funktioniert, liegt daran, dass C++ vor 1997 noch gar keine Namensbereiche kannte. Die Verwendungen der Headerdateien mit der Endung».h«wie zum Beispiel <iostream.h> funktionieren nur noch aus Gründen der Kompatibilität für ältere Programme. Als nun eine neudefinierte Version der Standardbibliothek mit vielen neuen Hilfsmitteln hinzugefügt wurde, war der Name der Headerdateien ein Problem. Hätte man hierbei wieder einen Namen wie <iostream.h> verwendet, so würde man Probleme mit älteren Programmen bekommen. Daher hat man kurzum beschlossen, das».h«aus den Standard-Headerdateien zu entfernen. Somit besitzen laut Standard die Headerdateien der Standardbibliothek jetzt keine Endung mehr. Das heißt auch, bei vielen Compiler ist jetzt gewöhnlich die Standard-Headerdateien doppelt vorhanden. Einmal mit der Endung».h«(veraltet) und einmal ohne (aktueller Standard), um die Kompatibilität zu älteren C++- Programmen zu erhalten. Bei den neuen Headerdateien ohne eine Endung wie <iostream> werden die Deklarationen im Namensbereich std platziert. Somit ist nach dem neuen Standard Folgendes korrekt: 237

33 3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen // namespace8.cpp #include <iostream> int main(void) { std::cout << "Aktueller Standard\n"; return 0; Oder auch mit der using-direktive (mit der Sie auch gleich die Kompatibilität zu älteren Programmen bewahren, die noch keine Namensräume kennen): // namespace9.cpp #include <iostream> using namespace std; int main(void) { cout << "Aktueller Standard\n"; return 0; Die Version, die Sie im Beispiel»namespace7.cpp«gesehen haben, ist somit nur noch geduldet, aber entspricht nicht mehr dem aktuellen Standard. Leider kann man nicht einfach den neuen Standard verwenden. Auf manchen Implementierungen (beispielsweise auf Uralt-Systemen) schlägt nämlich die Version ohne eine Endung der Standard-Headerdateien bei der Übersetzung fehl. Dann bleibt einem meistens nichts anderes mehr übrig, als die alte Version mit der Endung».h«zu verwenden. 3.3 C-Funktionen bzw. Bibliotheken in einem C++-Programm Es wurde bereits zuvor erwähnt, dass sich der Weg, eine Headerdatei einzubinden mit dem neuen C++-Standard geändert hat. Dies gilt auch für die Verwendung der Standardbibliotheks-Funktionen von C. Neben der Neuerung, dass die Headerdateien nicht mehr mit der Endung».h«(siehe Abschnitt 3.2.8) eingebunden werden, bekommen die Headerdateien von Standard-C das Zeichen»c«vorangestellt. Damit werden diese als C-Headerdateien gekennzeichnet und gleich sichtbar. Aus <stdio.h> wird also <cstdio>. Hierzu eine Liste von C-Headerdateien (siehe Tabelle 3.1), wie sie im ANSI C++ Standard eingebunden werden sollten, und das Gegenstück dazu in ANSI C: 238

34 C-Funktionen bzw. Bibliotheken in einem C++-Programm 3.3 ANSI C <assert.h> <ctype.h> <errno.h> <float.h> <iso646.h> <limits.h> <locale.h> <math.h> <setjmp.h> <signal.h> <stdarg.h> <stddef.h> <stdio.h> <stdlib.h> <string.h> <time.h> <wchar.h> <wtype.h> ANSI C++ <cassert> <cctype> <cerrno> <cfloat> <ciso646> <climits> <clocale> <cmath> <csetjmp> <csignal> <cstdarg> <cstddef> <cstdio> <cstdlib> <cstring> <ctime> <cwchar> <cwtype> Tabelle 3.1 Das ANSI C++ Gegenstück von ANSI C C-Funktionen aus einer C-Bibliothek aufrufen Dieser Abschnitt richtet sich an die schon etwas erfahreneren Programmierer, die bereits Programme in C geschrieben haben. Wenn Sie zum Beispiel eine C-Funktion aus einer C-Bibliothek aufrufen wollen, müssen Sie nicht den C-Quellcode neu kompilieren. Wollen Sie also in einem C++-Programm eine C-Funktion aus einer C-Bibliothek aufrufen, die mit einem C-Compiler übersetzt wurde, müssen Sie dies dem C++- Compiler bekannt geben: extern "C" typ funktion( parameter ); Damit teilen Sie dem C++-Compiler mit, dass die Funktion»funktion()«mit einem C-Compiler übersetzt wurde. Hier sollte man vielleicht noch darauf hinweisen, dass ein C++-Compiler Funktionsaufrufe anders übersetzt, weil dieser gegenüber C einige Spracherweiterungen (beispielsweise Überladung) besitzt. Natürlich können Sie hierbei auch mehrere C-Funktionen einer Bibliothek verwenden. Hierzu müssen Sie die Funktionen nur in geschweiften Klammern zusammenfassen: 239

35 3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen extern "C" { typ funktion1( parameter ); typ funktion2( parameter ); typ funktion3( parameter ); Sind diese C-Funktionen bereits in einer Headerdatei deklariert, so müssen Sie nur noch diese Datei einkopieren: extern "C" { #include "CFunktionen.h" Wollen Sie C-Funktionen oder Headerdateien sowohl für C als auch C++-Programme zur Verfügung stellen (was durchaus üblich ist), müssen Sie eine bedingte Kompilierung wie folgt verwenden: // Haben wir ein C++-Programm #ifdef cplusplus extern "C" { // Für das C++-Programm #endif // Für C und C++-Programme typ funktion1( parameter ); typ funktion2( parameter ); typ funktion3( parameter ); #ifdef cplusplus // Für das C++-Programm #endif Mit der vordefinierten symbolischen Konstante cplusplus können Sie feststellen, ob ein C oder C++-Compiler verwendet wird. Wenn es sich um einen C++- Compiler handelt, wird die extern "C"-Deklaration mit den geschweiften Klammern verwendet. Wenn Sie C-Funktionen in einem C++-Programm neu erstellen wollen, wie dies zum Beispiel nötig ist, wenn Sie eine C-Funktion aufrufen, die als Argument eine weitere C-Funktion erwartet (wie dies etwa bei den Standard-C-Funktionen bsearch() und qsort() der Fall ist), dann können Sie auch hier den C++-Compiler mit extern "C" anweisen, diese Funktion als C-Funktion zu übersetzen. Hierzu ein reines C-Programmbeispiel: /* bsearch.c */ #include <stdio.h> #include <stdlib.h> #include <string.h> /* Anzahl der Strings */ 240

36 C-Funktionen bzw. Bibliotheken in einem C++-Programm 3.3 #define MAX 5 /* Vergleichsfunktion für zwei Strings */ int cmp_str(const void *s1, const void *s2) { return (strcmp(*(char **)s1, *(char **)s2)); int main(void) { char *daten[max], puffer[80], *ptr, *key_ptr, **key_ptrptr; int count; /* Wörter eingeben */ printf("geben Sie %d Wörter ein\n", MAX); for (count = 0; count < MAX; count++) { printf("wort %d: ", count+1); fgets(puffer, 80, stdin); /* Speicher für das Wort Numer count reservieren */ daten[count] = (char *) malloc(strlen(puffer)+1); strcpy(daten[count], strtok(puffer,"\n") ); /* Die einzelnen Wörter sortieren */ qsort(daten, MAX, sizeof(daten[0]), cmp_str); /* Sortierte Daten ausgeben */ for (count = 0; count < MAX; count++) printf("\nwort %d: %s", count+1, daten[count]); /* Jetzt nach einem Wort suchen */ printf("\n\nnach welchem Wort wollen Sie suchen: "); fgets(puffer, 80, stdin); /* Zur Suche übergeben Sie zuerst den puffer an key, * danach benötigen Sie einen weiteren Zeiger, der * auf diesen Such-Schlüssel zeigt */ key_ptr = strtok(puffer, "\n"); key_ptrptr = &key_ptr; /* ptr bekommt die Adresse des Suchergebnisses */ ptr =(char *) bsearch(key_ptrptr, daten, MAX, sizeof(daten[0]), cmp_str); if(null == ptr) printf("kein Ergebnis für %s\n", puffer); else printf("%s wurde gefunden\n", puffer); return EXIT_SUCCESS; 241

37 3 Gültigkeitsbereiche, spezielle Deklarationen und Typumwandlungen Dies hier ist reiner C-Code. Wenn Sie nun die»dankbare«aufgabe haben, dieses Programm in ein C++-Programm umzuschreiben, haben Sie immer noch das Problem, dass die beiden Funktionen bsearch() und qsort() C-Funktionen als Argumente erwarten. Mit dem bisherigen Wissen und extern "C" können Sie dies durchaus selbst realisieren, wenn Sie wollen. Hier das Beispiel umgeschrieben in einen C++-Code. /* bsearch.cpp */ #include <iostream> #include <cstdio> #include <cstdlib> #include <cstring> using namespace std; // Anzahl der Strings const int MAX=5; const int BUF=80; // Vergleichsfunktion für zwei Strings extern "C" { int cmp_str(const void *s1, const void *s2) { return (strcmp(*(char **)s1, *(char **)s2)); int main(void) { char *daten[max], puffer[buf], *ptr, *key_ptr, **key_ptrptr; // Wörter eingeben cout << "Geben Sie " << MAX << " Wörter ein\n"; for (int count = 0; count < MAX; count++) { cout << "Wort " << (count+1) << ": "; cin.getline(puffer, BUF); // Speicher für das Wort Numer count reservieren daten[count] = new char [BUF+1]; strcpy(daten[count], strtok(puffer,"\n") ); // Die einzelnen Wörter sortieren qsort(daten, MAX, sizeof(daten[0]), cmp_str); // Sortierte Daten ausgeben for (int count = 0; count < MAX; count++) cout << "\nwort " << count+1 << ": " << daten[count]; 242