Jürgen Wolf. C++ von A bis Z. Das umfassende Handbuch
|
|
- Kora Schäfer
- vor 8 Jahren
- Abrufe
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
Jürgen Wolf. C++ von A bis Z. Das umfassende Handbuch. Galileo Press
Jürgen Wolf C++ von A bis Z Das umfassende Handbuch 'S Galileo Press Vorwort 17 Vorwort des Fachgutachters 23 1.1 Die Entstehung von C++ 25 1.1.1 Aufbau von C++ 27 1.2 Erste Schritte der C++-Programmierung
MehrUlla Kirch Peter Prinz C+ + Lernen und professionell anwenden. mitp
Ulla Kirch Peter Prinz C+ + Lernen und professionell anwenden mitp Inhaltsverzeichnis Einleitung 19 Grundlagen 21 Entwicklung und Eigenschaften von C++ 22 Objektorientierte Programmierung 24 Erstellen
Mehr1 Vom Problem zum Programm
Hintergrundinformationen zur Vorlesung GRUNDLAGEN DER INFORMATIK I Studiengang Elektrotechnik WS 02/03 AG Betriebssysteme FB3 Kirsten Berkenkötter 1 Vom Problem zum Programm Aufgabenstellung analysieren
MehrUnterprogramme. Funktionen. Bedeutung von Funktionen in C++ Definition einer Funktion. Definition einer Prozedur
Unterprogramme Unterprogramme sind abgekapselte Programmfragmente, welche es erlauben, bestimmte Aufgaben in wiederverwendbarer Art umzusetzen. Man unterscheidet zwischen Unterprogrammen mit Rückgabewert
MehrObjektorientierte Programmierung mit C++ Vector und List
Vector und List Ziel, Inhalt Wir lernen die Klassen vector und list aus der Standard-C++ Library kennen und anwenden. In einer Übung wenden wir diese Klassen an um einen Medienshop (CD s und Bücher) zu
MehrZählen von Objekten einer bestimmten Klasse
Zählen von Objekten einer bestimmten Klasse Ziel, Inhalt Zur Übung versuchen wir eine Klasse zu schreiben, mit der es möglich ist Objekte einer bestimmten Klasse zu zählen. Wir werden den ++ und den --
MehrJürgen Wolf. C++ von A bis Z. Das umfassende Handbuch. Galileo Press
Jürgen Wolf C++ von A bis Z Das umfassende Handbuch Galileo Press Auf einen Blick 1 Grundlagen in C++ 25 2 Höhere und fortgeschrittene Datentypen 133 3 Gültigkeitsbereiche, spezielle Deklarationen und
MehrEinführung in die Programmierung
: Inhalt Einführung in die Programmierung Wintersemester 2008/09 Prof. Dr. Günter Rudolph Lehrstuhl für Algorithm Engineering Fakultät für Informatik TU Dortmund - mit / ohne Parameter - mit / ohne Rückgabewerte
MehrFunktionen Häufig müssen bestimmte Operationen in einem Programm mehrmals ausgeführt werden. Schlechte Lösung: Gute Lösung:
Funktionen Häufig müssen bestimmte Operationen in einem Programm mehrmals ausgeführt werden. Schlechte Lösung: Der Sourcecode wird an den entsprechenden Stellen im Programm wiederholt Programm wird lang
Mehr1Schnelleinstieg 14. 2Wie aus einer einfachen Textdatei. 3 Wie man eigene Programme erstellt 30. Inhaltsverzeichnis. ein Programm wird 20
Inhaltsverzeichnis Liebe Leserin, lieber Leser!...13 1Schnelleinstieg 14 Welche Vorkenntnisse benötigen Sie für dieses Buch?...16 An wen richtet sich dieses Buch?...16 Was benötigen Sie, um die Programmiersprache
MehrVorkurs C++ Programmierung
Vorkurs C++ Programmierung Klassen Letzte Stunde Speicherverwaltung automatische Speicherverwaltung auf dem Stack dynamische Speicherverwaltung auf dem Heap new/new[] und delete/delete[] Speicherklassen:
MehrPropädeutikum. Dipl.-Inf. Frank Güttler
Propädeutikum 2015 Vorbereitungskurs Informatikstudium Erfolgreich Studieren Programmieren (C-Kurs) guettler@informatik.uni-leipzig.de Universität Leipzig Institut für Informatik Technische Informatik
MehrEinführung in die Java- Programmierung
Einführung in die Java- Programmierung Dr. Volker Riediger Tassilo Horn riediger horn@uni-koblenz.de WiSe 2012/13 1 Wichtig... Mittags keine Pommes... Praktikum A 230 C 207 (Madeleine + Esma) F 112 F 113
Mehr5 DATEN. 5.1. Variablen. Variablen können beliebige Werte zugewiesen und im Gegensatz zu
Daten Makro + VBA effektiv 5 DATEN 5.1. Variablen Variablen können beliebige Werte zugewiesen und im Gegensatz zu Konstanten jederzeit im Programm verändert werden. Als Variablen können beliebige Zeichenketten
Mehr2. Semester, 2. Prüfung, Lösung
2. Semester, 2. Prüfung, Lösung Name Die gesamte Prüfung bezieht sich auf die Programmierung in C++! Prüfungsdauer: 90 Minuten Mit Kugelschreiber oder Tinte schreiben Lösungen können direkt auf die Aufgabenblätter
MehrEinführung in die C++ Programmierung für Ingenieure
Einführung in die C++ Programmierung für Ingenieure MATTHIAS WALTER / JENS KLUNKER Universität Rostock, Lehrstuhl für Modellierung und Simulation 14. November 2012 c 2012 UNIVERSITÄT ROSTOCK FACULTY OF
MehrWintersemester Maschinenbau und Kunststofftechnik. Informatik. Tobias Wolf http://informatik.swoke.de. Seite 1 von 22
Kapitel 19 Vererbung, UML Seite 1 von 22 Vererbung - Neben der Datenabstraktion und der Datenkapselung ist die Vererbung ein weiteres Merkmal der OOP. - Durch Vererbung werden die Methoden und die Eigenschaften
MehrPass by Value Pass by Reference Defaults, Overloading, variable Parameteranzahl
Funktionen Zusammenfassung von Befehlssequenzen als aufrufbare/wiederverwendbare Funktionen in einem Programmblock mit festgelegter Schnittstelle (Signatur) Derartige prozedurale Programmierung erlaubt
MehrDie Programmiersprache C99: Zusammenfassung
Die Programmiersprache C99: Zusammenfassung Jörn Loviscach Versionsstand: 7. Dezember 2010, 19:30 Die nummerierten Felder sind absichtlich leer, zum Ausfüllen in der Vorlesung. Videos dazu: http://www.youtube.com/joernloviscach
MehrDeklarationen in C. Prof. Dr. Margarita Esponda
Deklarationen in C 1 Deklarationen Deklarationen spielen eine zentrale Rolle in der C-Programmiersprache. Deklarationen Variablen Funktionen Die Deklarationen von Variablen und Funktionen haben viele Gemeinsamkeiten.
MehrZiel, Inhalt. Programmieren in C++ Wir lernen wie man Funktionen oder Klassen einmal schreibt, so dass sie für verschiedene Datentypen verwendbar sind
Templates und Containerklassen Ziel, Inhalt Wir lernen wie man Funktionen oder Klassen einmal schreibt, so dass sie für verschiedene Datentypen verwendbar sind Templates und Containerklassen 1 Ziel, Inhalt
MehrArbeiten mit UMLed und Delphi
Arbeiten mit UMLed und Delphi Diese Anleitung soll zeigen, wie man Klassen mit dem UML ( Unified Modeling Language ) Editor UMLed erstellt, in Delphi exportiert und dort so einbindet, dass diese (bis auf
MehrEinführung in die C-Programmierung
Einführung in die C-Programmierung Warum C? Sehr stark verbreitet (Praxisnähe) Höhere Programmiersprache Objektorientierte Erweiterung: C++ Aber auch hardwarenahe Programmierung möglich (z.b. Mikrokontroller).
MehrEinführung in die Programmierung
Technische Universität München WS 2003/2004 Institut für Informatik Prof. Dr. Christoph Zenger Testklausur Einführung in die Programmierung Probeklausur Java (Lösungsvorschlag) 1 Die Klasse ArrayList In
MehrMethoden. von Objekten definiert werden, Methoden,, Zugriffsmethoden und Read-Only
Methoden Wie Konstruktoren und Destruktoren zum Auf- und Abbau von Objekten definiert werden, Wie inline-methoden Methoden,, Zugriffsmethoden und Read-Only Only- Methoden einzusetzen sind, Der this-pointer
MehrProgrammieren in C. Macros, Funktionen und modulare Programmstruktur. Prof. Dr. Nikolaus Wulff
Programmieren in C Macros, Funktionen und modulare Programmstruktur Prof. Dr. Nikolaus Wulff Der C Präprozessor Vor einem Compile Lauf werden alle Präprozessor Kommandos/Makros ausgewertet. Diese sind
MehrHochschule Darmstadt Informatik-Praktikum (INF 1) WS 2015/2016 Wirtschaftsingenieur Bachelor 5. Aufgabe Datenstruktur, Dateieingabe und -ausgabe
Aufgabenstellung Für eine Hausverwaltung sollen für maximal 500 Wohnungen Informationen gespeichert werden, die alle nach der gleichen Weise wie folgt strukturiert sind: Art Baujahr Wohnung Whnginfo Nebenkosten
MehrJava Kurs für Anfänger Einheit 4 Klassen und Objekte
Java Kurs für Anfänger Einheit 4 Klassen und Ludwig-Maximilians-Universität München (Institut für Informatik: Programmierung und Softwaretechnik von Prof.Wirsing) 13. Juni 2009 Inhaltsverzeichnis klasse
MehrKlausur in Programmieren
Studiengang Sensorik/Sensorsystemtechnik Note / normierte Punkte Klausur in Programmieren Wintersemester 2010/11, 17. Februar 2011 Dauer: 1,5h Hilfsmittel: Keine (Wörterbücher sind auf Nachfrage erlaubt)
MehrBinäre Bäume. 1. Allgemeines. 2. Funktionsweise. 2.1 Eintragen
Binäre Bäume 1. Allgemeines Binäre Bäume werden grundsätzlich verwendet, um Zahlen der Größe nach, oder Wörter dem Alphabet nach zu sortieren. Dem einfacheren Verständnis zu Liebe werde ich mich hier besonders
MehrWintersemester Maschinenbau und Kunststofftechnik. Informatik. Tobias Wolf http://informatik.swoke.de. Seite 1 von 18
Kapitel 3 Datentypen und Variablen Seite 1 von 18 Datentypen - Einführung - Für jede Variable muss ein Datentyp festgelegt werden. - Hierdurch werden die Wertemenge und die verwendbaren Operatoren festgelegt.
MehrHandbuch Fischertechnik-Einzelteiltabelle V3.7.3
Handbuch Fischertechnik-Einzelteiltabelle V3.7.3 von Markus Mack Stand: Samstag, 17. April 2004 Inhaltsverzeichnis 1. Systemvorraussetzungen...3 2. Installation und Start...3 3. Anpassen der Tabelle...3
MehrLineargleichungssysteme: Additions-/ Subtraktionsverfahren
Lineargleichungssysteme: Additions-/ Subtraktionsverfahren W. Kippels 22. Februar 2014 Inhaltsverzeichnis 1 Einleitung 2 2 Lineargleichungssysteme zweiten Grades 2 3 Lineargleichungssysteme höheren als
MehrErstellen einer Collage. Zuerst ein leeres Dokument erzeugen, auf dem alle anderen Bilder zusammengefügt werden sollen (über [Datei] > [Neu])
3.7 Erstellen einer Collage Zuerst ein leeres Dokument erzeugen, auf dem alle anderen Bilder zusammengefügt werden sollen (über [Datei] > [Neu]) Dann Größe des Dokuments festlegen beispielsweise A4 (weitere
MehrGrundlagen. Kapitel 1
Grundlagen Dieses Kapitel umfasst grundlegende Fragen und Aufgaben zur Erstellung von C++-Programmen. Hierzu zählen auch das Inkludieren von Header-Dateien Eine Header-Datei beinhaltet Informationen, die
MehrObjektorientierte Programmierung
Objektorientierte Programmierung 1 Geschichte Dahl, Nygaard: Simula 67 (Algol 60 + Objektorientierung) Kay et al.: Smalltalk (erste rein-objektorientierte Sprache) Object Pascal, Objective C, C++ (wiederum
MehrProfessionelle Seminare im Bereich MS-Office
Der Name BEREICH.VERSCHIEBEN() ist etwas unglücklich gewählt. Man kann mit der Funktion Bereiche zwar verschieben, man kann Bereiche aber auch verkleinern oder vergrößern. Besser wäre es, die Funktion
MehrC++ Grundlagen. ++ bedeutet Erweiterung zum Ansi C Standard. Hier wird eine Funktion eingeleitet
C++ Grundlagen ++ bedeutet Erweiterung zum Ansi C Standard Hier wird eine Funktion eingeleitet Aufbau: In dieser Datei stehen die Befehle, die gestartet werden, wenn das Programm gestartet wird Int main()
MehrOutlook. sysplus.ch outlook - mail-grundlagen Seite 1/8. Mail-Grundlagen. Posteingang
sysplus.ch outlook - mail-grundlagen Seite 1/8 Outlook Mail-Grundlagen Posteingang Es gibt verschiedene Möglichkeiten, um zum Posteingang zu gelangen. Man kann links im Outlook-Fenster auf die Schaltfläche
MehrMediator 9 - Lernprogramm
Mediator 9 - Lernprogramm Ein Lernprogramm mit Mediator erstellen Mediator 9 bietet viele Möglichkeiten, CBT-Module (Computer Based Training = Computerunterstütztes Lernen) zu erstellen, z. B. Drag & Drop
MehrObjektorientierte Programmierung für Anfänger am Beispiel PHP
Objektorientierte Programmierung für Anfänger am Beispiel PHP Johannes Mittendorfer http://jmittendorfer.hostingsociety.com 19. August 2012 Abstract Dieses Dokument soll die Vorteile der objektorientierten
MehrAngewandte Mathematik und Programmierung
Angewandte Mathematik und Programmierung Einführung in das Konzept der objektorientierten Anwendungen zu mathematischen Rechnens SS2013 Inhalt Projekt Vorlesung: praktische Implementierung üben Ein und
MehrDas Typsystem von Scala. L. Piepmeyer: Funktionale Programmierung - Das Typsystem von Scala
Das Typsystem von Scala 1 Eigenschaften Das Typsystem von Scala ist statisch, implizit und sicher 2 Nichts Primitives Alles ist ein Objekt, es gibt keine primitiven Datentypen scala> 42.hashCode() res0:
MehrEinführung in die Programmierung (EPR)
Goethe-Center for Scientific Computing (G-CSC) Goethe-Universität Frankfurt am Main Einführung in die Programmierung (EPR) (Übung, Wintersemester 2014/2015) Dr. S. Reiter, M. Rupp, Dr. A. Vogel, Dr. K.
MehrKurzanleitung fu r Clubbeauftragte zur Pflege der Mitgliederdaten im Mitgliederbereich
Kurzanleitung fu r Clubbeauftragte zur Pflege der Mitgliederdaten im Mitgliederbereich Mitgliederbereich (Version 1.0) Bitte loggen Sie sich in den Mitgliederbereich mit den Ihnen bekannten Zugangsdaten
MehrAndre Willms. Spielend C++ lernen. oder wie man Käfern Beine macht. Galileo Press
Andre Willms Spielend C++ lernen oder wie man Käfern Beine macht Galileo Press Vorwort 11 1 Das Abenteuer beginnt 13 1.1 Die Programmierumgebung installieren 15 1.2 Der erste Start 20 1.2.1 Visual C++registrieren
MehrÜbungen zu Einführung in die Informatik: Programmierung und Software-Entwicklung: Lösungsvorschlag
Ludwig-Maximilians-Universität München WS 2015/16 Institut für Informatik Übungsblatt 9 Prof. Dr. R. Hennicker, A. Klarl Übungen zu Einführung in die Informatik: Programmierung und Software-Entwicklung:
MehrVererbung & Schnittstellen in C#
Vererbung & Schnittstellen in C# Inhaltsübersicht - Vorüberlegung - Vererbung - Schnittstellenklassen - Zusammenfassung 1 Vorüberlegung Wozu benötigt man Vererbung überhaubt? 1.Um Zeit zu sparen! Verwendung
MehrFuxMedia Programm im Netzwerk einrichten am Beispiel von Windows 7
FuxMedia Programm im Netzwerk einrichten am Beispiel von Windows 7 Die Installation der FuxMedia Software erfolgt erst NACH Einrichtung des Netzlaufwerks! Menüleiste einblenden, falls nicht vorhanden Die
Mehr3. Auflage. O Reillys Taschenbibliothek. C# 5.0 kurz & gut. Joseph Albahari & Ben Albahari O REILLY. Aktualisierung von Lars Schulten
O Reillys Taschenbibliothek 3. Auflage C# 5.0 kurz & gut O REILLY Joseph Albahari & Ben Albahari Aktualisierung von Lars Schulten Inhalt C# 5.0 kurz & gut... 1 Ein erstes C#-Programm... 2 Syntax... 5 Typgrundlagen...
MehrObjektorientierte Programmierung. Kapitel 12: Interfaces
12. Interfaces 1/14 Objektorientierte Programmierung Kapitel 12: Interfaces Stefan Brass Martin-Luther-Universität Halle-Wittenberg Wintersemester 2012/13 http://www.informatik.uni-halle.de/ brass/oop12/
MehrMatrix42. Use Case - Sicherung und Rücksicherung persönlicher Einstellungen über Personal Backup. Version 1.0.0. 23. September 2015 - 1 -
Matrix42 Use Case - Sicherung und Rücksicherung persönlicher Version 1.0.0 23. September 2015-1 - Inhaltsverzeichnis 1 Einleitung 3 1.1 Beschreibung 3 1.2 Vorbereitung 3 1.3 Ziel 3 2 Use Case 4-2 - 1 Einleitung
MehrM. Graefenhan 2000-12-07. Übungen zu C. Blatt 3. Musterlösung
M. Graefenhan 2000-12-07 Aufgabe Lösungsweg Übungen zu C Blatt 3 Musterlösung Schreiben Sie ein Programm, das die Häufigkeit von Zeichen in einem eingelesenen String feststellt. Benutzen Sie dazu ein zweidimensionales
Mehr1. Übung zu "Numerik partieller Differentialgleichungen"
1. Übung zu "Numerik partieller Differentialgleichungen" Simon Gawlok, Eva Treiber Engineering Mathematics and Computing Lab 22. Oktober 2014 1 / 15 1 Organisatorisches 2 3 4 2 / 15 Organisatorisches Ort:
MehrDas erste Programm soll einen Text zum Bildschirm schicken. Es kann mit jedem beliebigen Texteditor erstellt werden.
Einfache Ein- und Ausgabe mit Java 1. Hallo-Welt! Das erste Programm soll einen Text zum Bildschirm schicken. Es kann mit jedem beliebigen Texteditor erstellt werden. /** Die Klasse hello sendet einen
MehrHANDBUCH PHOENIX II - DOKUMENTENVERWALTUNG
it4sport GmbH HANDBUCH PHOENIX II - DOKUMENTENVERWALTUNG Stand 10.07.2014 Version 2.0 1. INHALTSVERZEICHNIS 2. Abbildungsverzeichnis... 3 3. Dokumentenumfang... 4 4. Dokumente anzeigen... 5 4.1 Dokumente
MehrObjektbasierte Entwicklung
Embedded Software Objektbasierte Entwicklung Objektorientierung in C? Prof. Dr. Nikolaus Wulff Objektbasiert entwickeln Ohne C++ wird meist C im alten Stil programmiert. => Ein endlose while-schleife mit
MehrDelegatesund Ereignisse
Delegatesund Ereignisse «Delegierter» Methoden Schablone Funktionszeiger Dr. Beatrice Amrhein Überblick Definition eines Delegat Einfache Delegate Beispiele von Delegat-Anwendungen Definition eines Ereignisses
MehrWindows. Workshop Internet-Explorer: Arbeiten mit Favoriten, Teil 1
Workshop Internet-Explorer: Arbeiten mit Favoriten, Teil 1 Wenn der Name nicht gerade www.buch.de oder www.bmw.de heißt, sind Internetadressen oft schwer zu merken Deshalb ist es sinnvoll, die Adressen
MehrZusammengesetzte Datentypen -- Arrays und Strukturen
Zusammengesetzte Datentypen -- und Strukturen Informatik für Elektrotechnik und Informationstechnik Benedict Reuschling benedict.reuschling@h-da.de Hochschule Darmstadt Fachbereich Informatik WS 2013/14
MehrStellen Sie bitte den Cursor in die Spalte B2 und rufen die Funktion Sverweis auf. Es öffnet sich folgendes Dialogfenster
Es gibt in Excel unter anderem die so genannten Suchfunktionen / Matrixfunktionen Damit können Sie Werte innerhalb eines bestimmten Bereichs suchen. Als Beispiel möchte ich die Funktion Sverweis zeigen.
MehrProgrammierung in C. Grundlagen. Stefan Kallerhoff
Programmierung in C Grundlagen Stefan Kallerhoff Vorstellungsrunde Name Hobby/Beruf Schon mal was programmiert? Erwartungen an den Kurs Lieblingstier Für zu Hause C-Buch online: http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/
MehrProgrammieren in Java
Programmieren in Java objektorientierte Programmierung 2 2 Zusammenhang Klasse-Datei In jeder *.java Datei kann es genau eine public-klasse geben wobei Klassen- und Dateiname übereinstimmen. Es können
MehrAufklappelemente anlegen
Aufklappelemente anlegen Dieses Dokument beschreibt die grundsätzliche Erstellung der Aufklappelemente in der mittleren und rechten Spalte. Login Melden Sie sich an der jeweiligen Website an, in dem Sie
MehrS/W mit PhotoLine. Inhaltsverzeichnis. PhotoLine
PhotoLine S/W mit PhotoLine Erstellt mit Version 16.11 Ich liebe Schwarzweiß-Bilder und schaue mir neidisch die Meisterwerke an, die andere Fotografen zustande bringen. Schon lange versuche ich, auch so
MehrErwin Grüner 09.02.2006
FB Psychologie Uni Marburg 09.02.2006 Themenübersicht Folgende Befehle stehen in R zur Verfügung: {}: Anweisungsblock if: Bedingte Anweisung switch: Fallunterscheidung repeat-schleife while-schleife for-schleife
MehrKapitel 4 Die Datenbank Kuchenbestellung Seite 1
Kapitel 4 Die Datenbank Kuchenbestellung Seite 1 4 Die Datenbank Kuchenbestellung In diesem Kapitel werde ich die Theorie aus Kapitel 2 Die Datenbank Buchausleihe an Hand einer weiteren Datenbank Kuchenbestellung
MehrDer lokale und verteilte Fall
Lokale Beans Der lokale und verteilte Fall RemoteClient Lokaler Client (JSP) RemoteSession/Entity-Bean Lokale Session/Entity-Bean 2 Lokale Beans Die bisher vorgestellten EJBswaren immer in der Lage auf
MehrMenü Macro. WinIBW2-Macros unter Windows7? Macros aufnehmen
Menü Macro WinIBW2-Macros unter Windows7?... 1 Macros aufnehmen... 1 Menübefehle und Schaltflächen in Macros verwenden... 4 Macros bearbeiten... 4 Macros löschen... 5 Macro-Dateien... 5 Macros importieren...
MehrJava: Vererbung. Teil 3: super() www.informatikzentrale.de
Java: Vererbung Teil 3: super() Konstruktor und Vererbung Kindklasse ruft SELBSTSTÄNDIG und IMMER zuerst den Konstruktor der Elternklasse auf! Konstruktor und Vererbung Kindklasse ruft SELBSTSTÄNDIG und
MehrSpeicher in der Cloud
Speicher in der Cloud Kostenbremse, Sicherheitsrisiko oder Basis für die unternehmensweite Kollaboration? von Cornelius Höchel-Winter 2013 ComConsult Research GmbH, Aachen 3 SYNCHRONISATION TEUFELSZEUG
MehrDatenbanken Kapitel 2
Datenbanken Kapitel 2 1 Eine existierende Datenbank öffnen Eine Datenbank, die mit Microsoft Access erschaffen wurde, kann mit dem gleichen Programm auch wieder geladen werden: Die einfachste Methode ist,
MehrInstallation und Inbetriebnahme von Microsoft Visual C++ 2010 Express
Howto Installation und Inbetriebnahme von Microsoft Visual C++ 2010 Express Peter Bitterlich Markus Langer 12. Oktober 2012 Zusammenfassung Dieses Dokument erklärt Schritt für Schritt die Installation
MehrAGROPLUS Buchhaltung. Daten-Server und Sicherheitskopie. Version vom 21.10.2013b
AGROPLUS Buchhaltung Daten-Server und Sicherheitskopie Version vom 21.10.2013b 3a) Der Daten-Server Modus und der Tresor Der Daten-Server ist eine Betriebsart welche dem Nutzer eine grosse Flexibilität
Mehr5. Tutorium zu Programmieren
5. Tutorium zu Programmieren Dennis Ewert Gruppe 6 Universität Karlsruhe Institut für Programmstrukturen und Datenorganisation (IPD) Lehrstuhl Programmierparadigmen WS 2008/2009 c 2008 by IPD Snelting
MehrAnleitung über den Umgang mit Schildern
Anleitung über den Umgang mit Schildern -Vorwort -Wo bekommt man Schilder? -Wo und wie speichert man die Schilder? -Wie füge ich die Schilder in meinen Track ein? -Welche Bauteile kann man noch für Schilder
MehrComputeranwendung und Programmierung (CuP)
Computeranwendung und Programmierung (CuP) VO: Peter Auer (Informationstechnologie) UE: Norbert Seifter (Angewandet Mathematik) Organisatorisches (Vorlesung) Vorlesungszeiten Montag 11:15 12:45 Freitag
MehrFolge 18 - Vererbung
Workshop Folge 18 - Vererbung 18.1 Ein einfacher Fall der Vererbung Schritt 1 - Vorbereitungen Besorgen Sie sich - vielleicht aus einer der Übungen der Folge 17 - ein fertiges und lauffähiges Listenprojekt,
MehrVerhindert, dass eine Methode überschrieben wird. public final int holekontostand() {...} public final class Girokonto extends Konto {...
PIWIN I Kap. 8 Objektorientierte Programmierung - Vererbung 31 Schlüsselwort: final Verhindert, dass eine Methode überschrieben wird public final int holekontostand() {... Erben von einer Klasse verbieten:
MehrGemeinsamer Bibliotheksverbund: Übertragung von Datenexporten für den Verbundkatalog Öffentlicher Bibliotheken
Gemeinsamer Bibliotheksverbund: Übertragung von Datenexporten für den Verbundkatalog Öffentlicher Bibliotheken Mit Anleitung zur Erstellung einer FTP Verbindung unter Windows 7 Matthias Lange
MehrInformatik Kurs Simulation. Hilfe für den Consideo Modeler
Hilfe für den Consideo Modeler Consideo stellt Schulen den Modeler kostenlos zur Verfügung. Wenden Sie sich an: http://consideo-modeler.de/ Der Modeler ist ein Werkzeug, das nicht für schulische Zwecke
Mehr! " # $ " % & Nicki Wruck worldwidewruck 08.02.2006
!"# $ " %& Nicki Wruck worldwidewruck 08.02.2006 Wer kennt die Problematik nicht? Die.pst Datei von Outlook wird unübersichtlich groß, das Starten und Beenden dauert immer länger. Hat man dann noch die.pst
MehrNicht kopieren. Der neue Report von: Stefan Ploberger. 1. Ausgabe 2003
Nicht kopieren Der neue Report von: Stefan Ploberger 1. Ausgabe 2003 Herausgeber: Verlag Ploberger & Partner 2003 by: Stefan Ploberger Verlag Ploberger & Partner, Postfach 11 46, D-82065 Baierbrunn Tel.
MehrL10N-Manager 3. Netzwerktreffen der Hochschulübersetzer/i nnen Mannheim 10. Mai 2016
L10N-Manager 3. Netzwerktreffen der Hochschulübersetzer/i nnen Mannheim 10. Mai 2016 Referentin: Dr. Kelly Neudorfer Universität Hohenheim Was wir jetzt besprechen werden ist eine Frage, mit denen viele
MehrProseminar C-Programmierung. Strukturen. Von Marcel Lebek
Proseminar C-Programmierung Strukturen Von Marcel Lebek Index 1. Was sind Strukturen?...3 2. Padding 5 3. Vor- und Nachteile von Padding..8 4. Padding gering halten 9 5. Anwendungsgebiete von Strukturen.11
MehrII. Grundlagen der Programmierung. 9. Datenstrukturen. Daten zusammenfassen. In Java (Forts.): In Java:
Technische Informatik für Ingenieure (TIfI) WS 2005/2006, Vorlesung 9 II. Grundlagen der Programmierung Ekkart Kindler Funktionen und Prozeduren Datenstrukturen 9. Datenstrukturen Daten zusammenfassen
MehrNeuinstallation moveit@iss+ Einzelplatzversion
Neuinstallation moveit@iss+ Einzelplatzversion Hinweis: Gerne bietet Ihnen moveit Software die Durchführung einer lokalen Neuinstallation zu einem günstigen Pauschalpreis an. Die rasche und professionelle
MehrEine Einführung in C-Funktionen
Eine Einführung in C-Funktionen CGK-Proseminar 2014 Philip Gawehn 04.07.2014, Hamburg Inhaltsverzeichnis 1 Einleitung 2 2 Grundlagen 2 2.1 Der Aufbau einer Funktion....................... 2 2.2 Schlüsselwörter.............................
Mehr.NET Code schützen. Projekt.NET. Version 1.0
.NET Code schützen Projekt.NET Informationsmaterial zum Schützen des.net Codes Version 1.0 Autor: Status: Ablage: Empfänger: Seiten: D. Hoyer 1 / 6 Verteiler : Dokument1 Seite 1 von 1 Änderungsprotokoll
MehrAnton Ochsenkühn. amac BUCH VERLAG. Ecxel 2016. für Mac. amac-buch Verlag
Anton Ochsenkühn amac BUCH VERLAG Ecxel 2016 für Mac amac-buch Verlag 2 Word-Dokumentenkatalog! Zudem können unterhalb von Neu noch Zuletzt verwendet eingeblendet werden. Damit hat der Anwender einen sehr
MehrStundenerfassung Version 1.8 Anleitung Arbeiten mit Replikaten
Stundenerfassung Version 1.8 Anleitung Arbeiten mit Replikaten 2008 netcadservice GmbH netcadservice GmbH Augustinerstraße 3 D-83395 Freilassing Dieses Programm ist urheberrechtlich geschützt. Eine Weitergabe
Mehr4. BEZIEHUNGEN ZWISCHEN TABELLEN
4. BEZIEHUNGEN ZWISCHEN TABELLEN Zwischen Tabellen können in MS Access Beziehungen bestehen. Durch das Verwenden von Tabellen, die zueinander in Beziehung stehen, können Sie Folgendes erreichen: Die Größe
MehrJava Kurs für Anfänger Einheit 5 Methoden
Java Kurs für Anfänger Einheit 5 Methoden Ludwig-Maximilians-Universität München (Institut für Informatik: Programmierung und Softwaretechnik von Prof.Wirsing) 22. Juni 2009 Inhaltsverzeichnis Methoden
MehrDaten-Synchronisation zwischen dem ZDV-Webmailer und Outlook (2002-2007) Zentrum für Datenverarbeitung der Universität Tübingen
Daten-Synchronisation zwischen dem ZDV-Webmailer und Outlook (2002-2007) Zentrum für Datenverarbeitung der Universität Tübingen Inhalt 1. Die Funambol Software... 3 2. Download und Installation... 3 3.
MehrModellbildungssysteme: Pädagogische und didaktische Ziele
Modellbildungssysteme: Pädagogische und didaktische Ziele Was hat Modellbildung mit der Schule zu tun? Der Bildungsplan 1994 formuliert: "Die schnelle Zunahme des Wissens, die hohe Differenzierung und
MehrPrimzahlen und RSA-Verschlüsselung
Primzahlen und RSA-Verschlüsselung Michael Fütterer und Jonathan Zachhuber 1 Einiges zu Primzahlen Ein paar Definitionen: Wir bezeichnen mit Z die Menge der positiven und negativen ganzen Zahlen, also
MehrC++-Entwicklung mit Linux
C++-Entwicklung mit Linux Eine Einführung in die Sprache und die wichtigsten Werkzeuge von GCC und XEmacs bis Eclipse Thomas Wieland [Druckvorlage vom 10. August 2004] xiii Inhaltsverzeichnis 1 Programmieren
MehrUnsere Webapplikation erweitern
Unsere Webapplikation erweitern Um die Webapplikation zu benutzen: 1. Starten Sie den Server, indem Sie das Hauptprogramm in der Klasse ImdbServer starten. 2. Laden Sie im Browser die Seite http://localhost:8080/html/index.html.
MehrGrundlagen von Python
Einführung in Python Grundlagen von Python Felix Döring, Felix Wittwer November 17, 2015 Scriptcharakter Programmierparadigmen Imperatives Programmieren Das Scoping Problem Objektorientiertes Programmieren
MehrTESTEN SIE IHR KÖNNEN UND GEWINNEN SIE!
9 TESTEN SIE IHR KÖNNEN UND GEWINNEN SIE! An den SeniorNETclub 50+ Währinger Str. 57/7 1090 Wien Und zwar gleich in doppelter Hinsicht:!"Beantworten Sie die folgenden Fragen und vertiefen Sie damit Ihr
Mehr