new reference

C/C++
new reference
Übersicht
Grundlagen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
14
Sprachkonzepte und Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
41
Die C-Standardbibliothek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
247
Die C++-Standardbibliothek . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
329
13
Grundlagen
Grundlagen
Die Programmiersprachen C und C++
Im Gegensatz zu anderen Hochsprachen wie Pascal oder Basic, die ursprünglich als
reine Lehrsprachen konzipiert wurden, verdankt C seine Entstehung dem Umstand,
daß man bei Bell Laboratories eine höhere Programmiersprache für die Implementierung eines neu entwickelten Betriebssystems suchte. Bis dato programmierte man
das gesamte Betriebssystem, das später als UNIX bekannt wurde, nämlich in
Assembler. Um sich die Arbeit zu erleichtern, bastelte man an einer eigenen
Programmiersprache, die möglichst effizient, gut zu portieren und leicht zu compilieren sein sollte.
Brian W. Kernighan und Dennis M. Ritchie waren es, die diese Bemühungen zum
Erfolg führten und gleichzeitig eine der leistungsfähigsten Programmiersprachen
überhaupt schufen: die Programmiersprache C. In der Folgezeit fand C schnell
weite Verbreitung und wurde aufgrund seiner Qualitäten und trotz der Schwierigkeiten, denen sich gerade Anfänger bei der Erlernung dieser Sprache gegenüber
sehen, immer beliebter.
Mit der Zeit wandelten sich die Anforderungen an eine professionelle Programmiersprache. Neben der Erzeugung schneller und kompakter Codes trat die Wartbarkeit und Wiederverwertung bestehender Codes immer weiter in den Vordergrund, und damit auch das Interesse an objektorientierten Konzepten.
Mitte der Achtziger begann Bjarne Stroustrup C um objektorientierte Konzepte zu
erweitern. Die Betonung liegt dabei auf dem Wort »Erweiterung«, denn die Kompatibilität zu C war bei der Entwicklung der neuen Programmiersprache ein vordringliches Designmerkmal. Eine der ersten Stationen auf dem Weg zur neuen
Programmiersprache wurde daher noch als »C mit Klassen« bezeichnet. 1985 kam
dann eine Version heraus, die bereits zurecht als objektorientierte Programmiersprache gelten kann, und die unter dem Namen C++ bekannt wurde. Mittlerweile
ist C++ voll ausgereift und ebenso erfolgreich wie C.
Ein Grund hierfür ist sicherlich die (nahezu) vollständige Abwärtskompatibilität zu
C, die dem C-Programmierer den Einstieg in die objektorientierte Programmierung
wesentlich erleichtert und die Verwertbarkeit bereits existierenden C-Codes garantiert.
14
Leistungsmerkmale
Im Gegensatz zu rein objektorientierten Sprachen wie Modula oder Smalltalk
besteht damit allerdings auch die Gefahr, C++ lediglich als weniger strikte C-Version einzusetzen. Programmieren in C++ ist daher nicht automatisch mit objektorientierter Programmierung gleichzusetzen.
Leistungsmerkmale
C wurde ursprünglich als High-Level-Sprache zur Systemprogrammierung, namentlich der Entwicklung des Betriebssystems UNIX, konzipiert. Insofern war C nur ein
untergeordnetes Hilfsmittel, und C-Programme sollten einfach zu kompilieren und
schnell sein. Das Ergebnis war eine Sprache, die sich durch
●
ihren geringen Umfang an Sprachelementen,
●
die schnelle Laufzeit ihrer Programme,
●
die Unterstützung modularer Programmierung und
●
ihrer guten Portabilität bei gleichzeitiger Systemnähe
auszeichnete.
Heutzutage sieht die Situation so aus, daß Rechenzeit immer billiger und der Programmieraufwand immer kostspieliger wird. Ziel der objektorientierten Programmierung mit C++ ist es daher, Quelltext zu schaffen, der sich durch
●
einfache und sichere Verwendung,
●
hohe Wiederverwertbarkeit,
●
einfache Wartbarkeit,
●
gute Verständlichkeit und Lesbarkeit
auszeichnet.
Der ANSI-Standard
Der Erfolg einer Programmiersprache hängt nicht nur von der Sprache selbst,
sondern auch von der Verfügbarkeit passender Compiler (oder Interpreter) und
unterstützender Bibliotheken ab. Letztere waren für die Verbreitung von C sogar
von besonderer Bedeutung, da es in C für viele zentralen Aufgaben (Ein- und Ausgabe, Stringbearbeitung, dynamische Speicherverwaltung) keine in der Sprache verankerte Elemente gibt.
Die Abhängigkeit von Standardbibliotheken bedeutet aber auch zusätzliche Abhängigkeit von den Compiler-Entwicklern. Um diesem Einfluß entgegenzuwirken und zu
verhindern, daß jeder C-Compiler-Entwickler seinen eigenen C-Dialekt definiert, trat
im Jahre 1983 im American National Standard Institute (ANSI) ein Komitee aus
15
Grundlagen
Compiler-Herstellern, Software-Entwicklern und Hardware-Produzenten zusammen, das einen Standard für die Programmiersprache C erarbeiten sollte. Der 1989
ratifizierte Standard (Referenznummer ISO/IEC 9899:1990) definiert sowohl Syntax
und Semantik der Sprache wie auch die Zusammensetzung der Standardbibliothek.
Programmierer, die sich an die vom Standard vorgegebenen Regeln halten und
keine plattformspezifischen Funktionen verwenden (beispielsweise Programmierung
mit DOS-Interrupts), können dank des ANSI-Standards sicher sein, daß sie ihr Programm von jedem ANSI-kompatiblen Compiler erstellen lassen können. Dies
bedeutet aber auch, daß man ein Programm auf jedes beliebige System (Computer/
Betriebssystem) portieren kann, sofern es nur einen passenden ANSI-kompatiblen
Compiler für dieses System gibt.
1995 wurde die C-Standardbibliothek um eine Sammlung von Funktionen zur Programmierung mit sogenannten Wide Characters – Zeichen, die durch 16- und 32Bit-Zeichencodes codiert werden – ergänzt. Bei den meisten dieser Funktionen, die
in den neuen Headern wchar.h und wctype.h deklariert sind, handelt es sich um
Adaptionen bestehender C-Funktionen an den Zeichentyp wchar_t. Die Erweiterungen sind im Amendment ISO/IEC 9899:1990/Amd.1:1995(E) zusammengefaßt.
Auch für C++ gibt es mittlerweile einen ANSI-Standard. Die wichtigsten Neuerungen gegenüber dem bis dato geltenden Quasi-Standard von Bjarne Stroustrup dürften in der Einführung von Namensbereichen als frei definierbare globale Gültigkeitsbereiche und der Standardisierung der C++-Laufzeitbibliothek zu sehen sein.
Die Ausführungen und Beschreibungen in diesem Buch richten sich nach dem
neuen C++-Standard. Im Praxisteil dieses Buches finden Sie viele Abschnitte, die
zeigen, wie man die Klassen der C++-Laufzeitbibliothek bei der täglichen Programmierarbeit nutzen kann.
Obwohl die Abwärtskompatibilität zu C bei der Entwicklung von C++ höchste
Priorität hatte, wurden einige wenige der von C übernommenen Konzepte und Elemente in ihrer Semantik geändert (siehe Anhang). Sollte sich ein C-Programm nach
der Kompilation mit einem C++-Compiler anders als zuvor verhalten, sollte man
prüfen, ob das Programm von diesen Änderungen betroffen ist.
Bezugsquellen
C- und C++-Standard können Sie online beim ANSI-Institut oder IHS (Information
Handling Service) anfordern:
www.ansi.org
www.ihs.de
Kopien der Standards können auch aus der Schweiz
ISO/IEC Copyright Office
Case Postale 56
CH-1211 Genève 20
Schweiz
16
Schreibkonventionen in C/C++
oder aus München bezogen werden:
IHS Information Handling Services
Tel. 089 / 89526999
Den abschließenden C++-Draft kann man sich derzeit noch aus dem Internet herunterladen:
ftp://ftp.maths.warwick.ac.uk/pub/c++/std/cd2/
Schreibkonventionen in C/C++
Bei der Festlegung der Namen von Bezeichnern, das sind Variablen-, Funktions-,
Klassen-, Typen- und Makronamen, dürfen folgende Zeichen benutzt werden:
●
alle Buchstaben des englischen Alphabets (a bis z, A bis Z)
●
die Ziffern 0 bis 9
●
der Unterstrich »_«
●
●
●
Der Name eines Bezeichners muß mit einem Buchstaben oder dem Unterstrich
beginnen. Die Verwendung einer Ziffer als ersten Buchstaben eines Bezeichners ist nicht erlaubt.
Die deutschen Umlaute und andere Sonderzeichen dürfen also nur in Kommentaren und in Zeichenketten vorkommen.
Die maximale Länge der Bezeichner ist nicht vorgeschrieben, jedoch müssen
nach ANSI C mindestens die ersten 31 Zeichen zur Unterscheidung herangezogen werden.
Warnung
Die Sprache C unterscheidet zwischen Groß- und Kleinschreibung. Die Bezeichner
var1 und Var1 können also für zwei verschiedene Variablen benutzt werden.
Aufbau eines C/C++-Programms
#include <stdio.h>
int main()
{
/* Anweisungen */
return 0;
}
17
Grundlagen
Beschreibung
C/C++-Programme bestehen aus einer Ansammlung von Deklarationen und Definitionen von
Datentypen, Variablen, Funktionen und Klassen (sowie einigen speziellen Direktiven an den
Präprozessor). Anweisungen, die festlegen, was ein Programm macht, findet man nur innerhalb
von Funktionsdefinitionen (in C++ auch in den Methoden (Elementfunktionen) der Klassen).
Jedes C/C++-Programm muß eine
main()-Funktion
definieren, mit deren Ausführung das
Programm beginnt.
Anwendung
Im einfachsten Fall besteht ein C/C++-Programm
aus einer oder mehreren include-Direktiven, die den Zugriff auf bestimmte
Funktionen und Klassen der C/C++-Standardbibliotheken ermöglichen, sowie
●
der obligatorischen Funktion main(), in der alle Anweisungen zur Ausführung
des Programms stehen,
●
aus Variablen, die deklariert werden, um Werte zu repräsentieren und zwischenzuspeichern,
●
aus Anweisungen, in denen die Werte in den Variablen bearbeitet werden.
●
Beispiel
Um ein einfaches Programm aufzusetzen, das zwei Zahlen multipliziert und das
Produkt der beiden Zahlen ausgibt, könnte man folgendermaßen vorgehen:
Um zwei ganzzahlige Werte im Programm verwalten zu können, deklariert man
zwei Variablen des Datentyps int (Datentyp für ganzzahlige Werte). Für das Ergebnis kann man eine dritte Variable definieren.
int main()
{
int zahl1, zahl2;
int ergebnis;
Mit Hilfe des Zuweisungsoperators kann man den Variablen Werte zuweisen:
int main()
{
...
zahl1 = 120;
zahl2 = 4;
/* Werte zuweisen */
Zur Multiplikation von int-Werten verwendet man den *-Operator. Das Ergebnis
der Berechnung weist man direkt der dritten Variablen zu.
ergebnis = zahl1 * zahl2;
18
Aufbau eines C/C++-Programms
Um Werte auszugeben, kann man sich einer speziellen Funktion namens printf()
bedienen, die Teil der C-Laufzeitbibliothek ist.
printf("Das Produkt der Zahlen ist : %d\n", ergebnis);
Bevor man eine Funktion aufruft, muß die Funktion allerdings dem Compiler per
Deklaration bekanntgemacht worden sein. Die Deklarationen für die Funktionen
der Laufzeitbibliothek sind in einer Reihe von Header-Dateien zusammengefaßt.
Nachdem man sich erkundigt hat, in welcher Header-Datei die gewünschte Funktion deklariert ist, bindet man die Header-Datei mittels einer #include-Anweisung
am Anfang des Programms ein.
#include <stdio.h>
Warnung
Leser, die mit C/C++ für Windows programmieren wollen, seien darauf hingewiesen, daß Windows-Programme statt der main()-Funktion die Funktion WinMain()
verwenden. Je nach verwendetem Compiler und Klassenbibliothek kann WinMain()
selbst wieder durch eine andere Funktion (beispielsweise OwlMain() für Borland C++
mit OWL) oder eine Klasseninstanz (beispielsweise ein globales Objekt der MFCKlasse CWinApp in Visual C++) ersetzt sein.
Konsolenprogramme, die unter Windows ausgeführt werden (sprich im Fenster der
MS-DOS-Eingabeaufforderung ablaufen und über keine eigene Windows-Oberfläche verfügen), verwenden aber wie reine DOS- oder UNIX-Programme die main()Funktion.
Beispiel
Das folgende Programm kann nach der Kompilation von der Konsole (unter Windows die MS-DOS-Eingabeaufforderung) Ihres Betriebssystems aus aufgerufen und
ausgeführt werden.
#include <stdio.h>
int main()
{
int zahl1, zahl2;
int ergebnis;
/* Faktoren */
/* Produkt */
zahl1 = 120;
/* Werte zuweisen */
zahl2 = 4;
ergebnis = zahl1 * zahl2; /* Wert berechnen */
printf("Das Produkt der Zahlen ist : %d\n", ergebnis);
return 0;
}
19
Grundlagen
Verweise
Siehe nachfolgende Abschnitte für weitere einführende Informationen zum Aufbau
von C/C++-Programmen.
Siehe Kapitel zur Sprache für detaillierte Informationen zu Variablen, Datentypen,
Operatoren, Funktionen.
Typische Komponenten von C/C++-Programmen
/* Das erste C-Programm */
#include <stdio.h>
Kommentar
Präprozessor-Direktive
Funktion
int main()
{
printf("Hello World\n");
return 0;
}
Anweisungs
-block
Anweisungen
Typische Komponenten eines C/C++-Programms
Beschreibung
Die Funktionalität eines Programmes wird bestimmt durch die Daten, die es verarbeitet, und die
Operationen,
die
es
auf
den
Daten
ausführt.
Insofern
könnte
man
meinen,
ein
Programm
bestünde nur aus Variablendefinitionen und Anweisungen. Dem ist aber nicht so. Der Compiler
unterscheidet noch ganz andere Elemente.
20
Typische Komponenten von C/C++-Programmen
Aus Sicht des Compilers besteht ein Programm aus:
– Definitionen
– Deklarationen
– Anweisungen
– Präprozessor-Direktiven
– Kommentaren
Definitionen und Deklarationen
Bei Ausführung des Programms müssen der Code und die Daten des Programms in
den Arbeitsspeicher des Computers geladen werden. Welcher Code und welche
Daten zu einem Programm gehören, legen Sie beim Aufsetzen des Quelltextes selbst
fest.
Der Code des Programms besteht aus den in Maschinencode übersetzten Anweisungen aus dem Quelltext. In C/C++ dürfen Anweisungen nur in Funktionsdefinitionen stehen. Indem Sie eine Funktion definieren, beispielsweise die main()-Funktion des Programms, teilen Sie dem Compiler mit, daß er für die Funktion Speicher
reservieren und dafür Sorge tragen soll, daß der Code der Funktion bei Aufruf des
Programms an die entsprechende Stelle im Speicher geladen wird.
Für die Verwaltung der Daten definieren Sie Variablen. Hinter den Variablen
stehen Speicherbereiche im RAM, die der Compiler für Sie reserviert. In den Variablen können Sie die Daten Ihres Programms speichern.
Durch eine Definition führt man neue Elemente (Funktionen, Variablen, Datentypen) in ein Programm ein. Gleichzeitig wird das Element im Zuge der Definition
mit einem Bezeichner verbunden (Variablenname, Funktionsname, etc.), der im
Programmquelltext verwendet wird, um auf das Element zuzugreifen.
Da mit der Definition von Funktionen und Variablen die Bereitstellung von Speicherbereichen einhergeht, müssen diese Elemente eindeutig sein, d. h., sie dürfen
nur einmal im ganzen Programm definiert sein (sonst gäbe es Bezeichner, die mit
mehreren Speicherbereichen assoziert wären). Andererseits fordert der Compiler,
daß alle Elemente, die man verwendet, ihm vorab bekanntgemacht werden müssen.
Bevor man eine Variable verwendet, muß man dem Compiler mitteilen, welchen
Datentyp die Variable hat, bevor man eine Funktion aufrufen kann, muß man dem
Compiler mitteilen, welche Parameter die Funktion übernimmt und was für einen
Rückgabetyp sie zurückliefert. Die Bekanntmachung der Elemente bezeichnet man
als Deklaration. Grundsätzlich ist jede Definition auch eine Deklaration. Es gibt
aber auch die Möglichkeit, Elemente zu deklarieren, ohne daß man die Elemente
neu deklariert. Für Variablen stellt man dabei der »Definition« das Schlüsselwort
extern voran, für Funktionen gibt man nur den Funktionskopf (Rückgabetyp,
Name, Parameterliste) ohne Anweisungsteil an.
21
Grundlagen
Verweise
Siehe Elemente der Sprache.
Variablen und Konstanten
Feste Werte, die sich im Laufe des Programms nicht ändern oder nur einmal benötigt werden, kann man direkt in Form von Literalen in den Quelltext schreiben.
Für veränderliche Werte definiert man Variablen. Der Compiler weist der Variablen einen Speicherbereich zu, in den man im Laufe des Programms verschiedene
Werte abspeichern kann.
Eine Variable kann aber immer nur Werte eines Datentyps aufnehmen (mit Ausnahme der unions). Dies liegt daran, daß unterschiedliche Daten (Buchstabe, ganzzahliger Wert, Gleitkommawert) unterschiedlich viel Speicher benötigen. Auch die
Codierung der Werte in Binärdarstellung für die Ablage im RAM ist für die einzelnen Datentypen unterschiedlich. Aus diesem Grund gehört jede Variable einem
Datentyp an, der bei der Definition der Variablen vom Programmierer angegeben
wird.
int var1;
double var2;
char var3;
var1 = 3;
var2 = 3.14;
var3 = 'c';
//
//
//
//
//
//
Deklaration einer Variablen für ganzzahlige Werte
Deklaration einer Variablen für Gleitkommawerte
Deklaration einer Variablen für Zeichen
Zuweisung einer ganzzahligen Konstanten
Zuweisung einer Gleitkommakonstanten
Zuweisung einer Zeichenkonstanten
Verweise
Siehe Abschnitt, Kategorie Variablen und Datentypen.
Anweisungen
;
Der eigentliche Code des Programms. Die Anweisungen werden vom Compiler in
Maschinenbefehle umgesetzt, die vom Prozessor des Computers bei Ausführung des
Programms nacheinander abgearbeitet werden. Anweisungen enden stets mit einem
Semikolon.
●
●
●
●
22
Anweisungen dürfen nur innerhalb der Anweisungsblöcke von Funktionen
stehen.
Jede Programmanweisung muß mit einem Semikolon abgeschlossen werden.
Mehrere Anweisungen können – durch Semikolons getrennt – in einer Zeile
stehen.
Außer Anweisungen werden auch Deklarationen mit einem Semikolon abgeschlossen.
Typische Komponenten von C/C++-Programmen
var1 = 3 * var2;
printf("Hallo");
return 0;
//
//
//
//
//
Zuweisung eines Wertes
an eine Variable
Aufruf einer Funktion
Schlüsselwort zur Beendigung
einer Funktion
Anweisungsblöcke
{}
In C/C++ werden Anweisungen in Anweisungsblöcken zusammengefaßt. Ein
Anweisungsblock beginnt mit einer öffnenden geschweiften Klammer und endet
mit einer schließenden geschweiften Klammer.
Anweisungsblöcke können ineinander verschachtelt werden. Der äußerste Block ist
dabei stets der Definitionsblock einer Funktion. Innerhalb des Anweisungsblocks
der Funktion kann man weitere Blöcke definieren, beispielsweise zur Implementierung einer Schleife oder zur Verzweigung des Programmablaufs in Abhängigkeit
von einer if-Bedingung .
void func()
{
long loop = 1;
// Funktion
// Anweisungsblock zu Schleife
while (loop <= 10)
// Schleife und Schleifenbedingung
{
// Anweisungsblock zu Schleife
// Potenzen berechnen
printf("%d ^ %d = %f\n", loop, loop, pow(loop,loop));
loop++;
}
}
Funktionen
Funktionen unterstützen die Modularisierung des Quellcodes. Statt alle Anweisungen in die main()-Funktion zu schreiben, kann man zusammengehörende Anweisungen, die eine gemeinsame Aufgabe erfüllen, als Funktionen auslagern.
Eine Funktion verfügt über
●
einen Anweisungsblock,
●
eine Schnittstelle zu den anderen Teilen des Programms und
●
einen Namen, über den die Funktion aufgerufen werden kann.
Die folgende Funktion vergleich() definiert zwei Parameter, denen beim Aufruf der
Funktion Werte übergeben werden können. Als Ergebnis liefert die Funktion mittels des Schlüsselworts return einen ganzzahligen Wert zurück, der anzeigt, ob die
beiden übergebenen Werte gleich oder unterschiedlich sind.
Funktionsdefinition:
int
{
vergleich (int parameter1, int parameter2)
23
Grundlagen
if (parameter1 == parameter2)
return 1;
else
return 0;
}
Funktionsaufruf:
int ergebnis;
int var = 25;
ergebnis = vergleich(23, var);
// weist ergebnis den Wert 0 zu
Verweise
Siehe Kapitel Funktionen.
Präprozessor-Direktiven
#
Präprozessor-Direktiven sind spezielle Anweisungen an den Compiler (genauer
gesagt, den Präprozessor), die vor der eigentlichen Übersetzung des Programms in
Maschinencode ausgeführt werden. Präprozessor-Direktiven beginnen stets mit
einem »#« und stehen immer allein in einer Zeile.
Die wichtigste Präprozessor-Direktive lautet: #include. Sie dient dazu, den Inhalt
einer Textdatei in den Quelltext der aktuellen Datei einkopieren zu lassen. In
C/C++ werden selbst Anfänger gleich mit diesem Konzept konfrontiert, da man nur
auf diese Weise auf die Funktionen/Klassen der Standardbibliothek zugreifen kann.
Die Standardbibliotheken von C und C++ liegen als kompilierte LIB-Dateien vor
und enthalten die Definitionen einer Reihe von nützlichen Funktionen (und Klassen). Um eine dieser Funktion in einem Programm aufrufen zu können, muß man
die Funktion zuvor beim Compiler bekanntmachen. Dies geschieht durch eine
Deklaration.
Um dem Programmierer die Tipparbeit für die Deklaration der Bibliothekselemente
zu ersparen, sieht der ANSI-Standard eine Reihe von Header-Dateien vor, in denen
die Deklarationen der Bibliothekselemente stehen. Jede Header-Datei ist einem speziellen Themengebiet gewidmet. Die Funktion printf() zur Textausgabe fällt beispielsweise in den Bereich Ein- und Ausgabe, englisch Input/Output (IO), ihre
Deklaration ist in der Header-Datei stdio.h enthalten. Statt printf() und weitere
Funktionen zur Ein- und Ausgabe extra im Programm vorab zu deklarieren, genügt
es daher die Header-Datei stdio.h einzubinden:
#include <stdio.h>
24
Typische Komponenten von C/C++-Programmen
Kommentare
/* */ und //
Kommentare sind Textpassagen, die vom Compiler ignoriert werden. Sie erlauben
dem Programmierer, Anmerkungen in den Quelltext aufzunehmen – meist zur
Erklärung des nebenstehenden oder nachfolgenden C/C++-Codes.
C
Kommentare beginnen in C mit der Zeichenkombination Schrägstrich – Stern »/*«
und enden mit der Zeichenkombination Stern – Schrägstrich »*/«. Die dazwischenstehenden Zeichen werden vom Compiler ignoriert. Dies gilt auch für das Zeilenendezeichen, so daß sich Kommentare auch über mehrere Zeilen erstrecken dürfen.
Sie dürfen jedoch nach dem ANSI-Standard nicht verschachtelt werden. (Einige
Compiler erlauben optional die Verschachtelung von Kommentaren.)
/* Dies ist ein Kommentar, der sich über mehrere – genauer gesagt zwei Zeilen erstreckt */
/* Das folgende Programm gibt einen Gruß auf den */
/* Bildschirm Ihres Computers aus
*/
#include <stdio.h>
int main()
{
printf("Hallo!\n"); /* Aufruf einer Funktion */
return 0;
}
C++
In C++ kann die Auskommentierung auch durch doppelte Schrägstriche »//« erfolgen. Der nachfolgende Kommentar reicht bis zum Zeilenende. In C++ können beide
Konzepte zur Kommentierung unabhängig voneinander verwendet werden.
/* Das folgende Programm gibt einen Gruß auf den */
/* Bildschirm Ihres Computers aus
*/
#include <stdio.h>
int main()
{
printf("Hallo!\n"); // Aufruf einer Funktion
return 0;
}
Tip
In C++ bietet es sich an, innerhalb von Anweisungsblöcken nur //-Kommentare zu
verwenden und die Klammern /* und */ zum Auskommentieren größerer Blöcke
beim Debuggen einzusetzen.
25
Grundlagen
Größere Programme und Modularisierung
Beschreibung
Beim Aufsetzen größerer Programme empfiehlt es sich, den Code zu modularisieren, statt
diesen Anweisung für Anweisung untereinander in die
main()-Funktion zu schreiben.
Die Modularisierung und Strukturierung des Codes sieht so aus, daß man
– einerseits Anweisungen und Code in Form von Funktionen und Klassen (nur C++) organisiert,
– andererseits den Quelltext selbst auf mehrere Dateien verteilt.
Aufteilung in Funktionen und Klassen
Größere Programmieraufgaben löst man üblicherweise, indem man Teilaufgaben
formuliert und diese in Form eigener Funktionen löst. Ein Programm, das zwei
Daten einliest, auf der Grundlage der Daten eine Berechnung ausführt und dann
das Ergebnis ausgibt, könnte drei Teilaufgaben definieren:
●
Daten einlesen
●
Berechnung durchführen
●
Daten ausgeben
Für jede dieser Teilaufgaben könnte man eine eigene Funktion definieren (wobei
man für die Ein- und Ausgabe in einfachen Fällen auch direkt die entsprechenden
Funktionen der Laufzeitbibliothek verwenden kann).
Die Aufteilung in Funktionen hat den Vorteil, daß
●
der Quelltext übersichtlicher ist,
●
der Quelltext einfacher zu debuggen und zu warten ist.
Letzeres gilt insbesondere, wenn eine der Teilaufgaben mehrfach auszuführen ist.
Statt jedes Mal die zugehörigen Anweisungen einzutippen, ruft man nur die entsprechende Funktion auf. Der Code wird nur einmal – in der Funktionsdefinition –
aufgesetzt. Stellt sich heraus, daß die Funktion fehlerhaft ist oder erweitert werden
muß, kann dies zentral in der Funktionsdefinition geschehen.
In C++ kann Code nicht nur in Funktionen, sondern auch in Klassen (Datentypen,
in denen Variablen und Funktionen zusammengefaßt werden) organisiert werden.
Aufteilung in mehrere Quelltextdateien
Umfangreichen Code kann man auf mehrere Quelltextdateien verteilen. Dies ist
beispielsweise angebracht, wenn man eine Sammlung von nützlichen Funktionen in
einer eigenen Datei verwahren will (meist der erste Schritt zu einer eigenen Bibliothek), oder wenn man zu mehreren an einem größeren Programmprojekt arbeitet.
Aufgabe des Compilers und Linkers ist es dabei, die einzelnen Quelltextdateien zu
einem Programm zusammenzufassen.
26
Größere Programme und Modularisierung
Alle Quelltextdateien, die zusammen in einem Schritt vom Compiler übersetzt und
zu einer Objektdatei kompiliert werden, bezeichnet man als Modul oder Übersetzungseinheit. Eine Übersetzungseinheit besteht aus einer Implementierungsdatei
(Extension .c oder .cpp) und allen Quelltextdateien, deren Inhalt direkt oder indirekt per #include-Anweisung eingebunden werden.
Beispiel
Für ein Programm, das zwei Zahlen von der Tastatur einliest und sowohl das Produkt als auch den Mittelwert der beiden Zahlen berechnet und ausgibt, könnte
man beispielsweise zwei spezielle Funktionen zur Berechnung des Produkts und des
Mittelwerts aufsetzen und diese dann in der main()-Funktion aufrufen.
(Für zwei so simple Berechnungen wie das Produkt und den Mittelwert zweier Zahlen, würde man in der Praxis allerdings keine eigene Funktion aufsetzen. Doch geht
es hier nur darum, das Prinzip der Modularisierung zu verdeutlichen.)
#include <stdio.h>
int produkt_berechnen(int z1, int z2) {
int ergebnis;
ergebnis = z1 * z2;
return ergebnis;
/* Produkt berechnen */
/* Ergebnis zurückliefern */
}
double mittelwert_berechnen(int z1, int z2) {
double ergebnis;
ergebnis = (z1 + z2)/2.0;
return ergebnis;
/* Mittelwert berechnen */
/* Ergebnis zurückliefern */
}
int main(int argc, char **argv)
{
/* Variablen deklarieren */
int zahl1, zahl2;
int produkt;
double mittelwert;
/* Zahlenwerte einlesen */
printf("Geben Sie zwei Zahlen zwischen 0 und 100 ein: \n\n");
scanf("%d %d", &zahl1, &zahl2);
fflush(stdin);
/* Ergebnisse berechnen */
produkt
= produkt_berechnen(zahl1, zahl2);
mittelwert = mittelwert_berechnen(zahl1, zahl2);
27
Grundlagen
/* Ergebnisse ausgeben */
puts("\n");
printf("Produkt
= %d\n", produkt);
printf("Mittelwert = %f\n", mittelwert);
return 0;
}
Verweise
Siehe Abschnitt zur Sprache für detailliertere Informationen zu Funktionen und
Klassen.
Objektorientiertes Programmieren
Objektorientiert zu programmieren bedeutet nicht einfach, sich die Annehmlichkeiten von C++ gegenüber C zunutze zu machen oder die Klassenbibliotheken statt
der C-Bibliotheken zu benutzen. In diesem strengeren Sinne kann man das folgende
Programmbeispiel, in dem statt der C-Funktion printf() die Klasseninstanz cout
und der überladene <<-Operator verwendet werden, nicht als objektorientiert programmiert bezeichnen.
Beispiel
/* Das erste C++-Programm. */
#include <iostream>
using namespace std;
int main() {
cout << "Hello world!" << endl;
return 0;
}
Objektorientierte Programmierung beginnt eigentlich erst da, wo Klassen definiert
und die wichtigen Konzepte der Kapselung und des Polymorphismus sinnvoll eingesetzt werden, und sie rechtfertigt sich vor allem dort, wo Klassenbibliotheken entstehen, die sich leicht und sicher verwenden lassen.
Letztendlich laufen alle wesentlichen Konzepte der objektorientierten Programmierung darauf hinaus, den Prozeß der Programmentwicklung zu beschleunigen,
sei es durch
●
●
28
die Wiederverwertbarkeit bereits implementierter Codes,
schnellere Entwicklung von Datentypen durch Vererbung und Polymorphismus,
Verwendung der Standardbibliotheken
●
geringere Fehleranfälligkeit durch Kapselung oder
●
eine bessere Lesbarkeit der Programme, dank der objektorientierten Sichtweise.
Wo diese Kriterien nicht greifen, spricht nichts gegen eine Implementierung in C,
wobei der Verzicht auf die objektorientierten Konzepte eine geringere Codegröße
und bessere Laufzeiten mit sich bringt.
Verweise
Siehe Kapitel über Klassen.
Verwendung der Standardbibliotheken
#include
Beschreibung
Zu C und C++ gehört eine umfangreiche Sammlung von Funktionen und Klassen, die der Bewältigung der wichtigsten Programmieraufgaben dienen – etwa der Ein- und Ausgabe von Daten,
der Programmierung mit Zeichenketten (Text), der Verwendung mathematischer Funktionen
wie Sinus, Kosinus, Potenz, etc.
Anwendung
C/C++ verfügt über einen recht kleinen Satz von Schlüsselwörtern, etlichen Operatoren und einer äußerst umfangreichen Sammlung von Syntaxregeln, die vorschreiben, wie man Schlüsselwörter, Operatoren und selbst definierte Bezeichner zu
korrekten C/C++-Programmen verknüpft.
Das Potential dieser Sprachelemente und -regeln ist enorm, doch wäre die Entwicklung selbst einfachster Programme allein mit diesen Sprachelementen eine mühsame
Angelegenheit, denn selbst für elementarste Programmieraufgaben bieten diese
Sprachelemente keine Unterstützung. So müßte man
●
●
●
zum Kopieren von Zeichenketten (sprich Textpassagen) Schleifen programmieren, in denen die Zeichenfolgen Zeichen für Zeichen kopiert werden,
zur Berechnung des Sinus einer Zahl sich zuerst in einem Lehrbuch der Mathematik darüber informieren, wie man den Sinus einer Zahl durch Berechnung
einer trigonometrischen Reihe annähern kann,
für Ein- und Ausgaben auf Betriebssystemebene programmieren.
29
Grundlagen
Voraussehende Programmierer werden diese häufig wiederkehrenden Programmieraufgaben in Form von eigenen Funktionen implementieren, damit sie – etwa bei der
Berechnung des nächsten Sinus – nicht mehr die ganze Berechnung ausführen
müssen, sondern nur noch die entsprechende Funktion aufrufen müssen.
Klevere Programmierer wissen, daß genau dies für die wichtigsten Programmieraufgaben bereits geschehen ist. Bevor Sie jedoch eine dieser Funktionen (für C++ auch
Klassen) aufrufen und verwenden können, müssen Sie
●
●
●
sich informieren, welche Funktion / Klasse Ihr Problem lösen könnte (siehe
Referenz der Laufzeitbibliotheken)
sich informieren, wie die Funktion / Klasse verwendet wird (siehe Referenz der
Laufzeitbibliotheken). Für Funktionen ist es beispielsweise wichtig, welche
Argumente man der Funktion beim Aufruf übergibt und welchen Ergebniswert
die Funktion zurückliefert.
dem Compiler, der Ihren Programmquelltext übersetzt, die Funktion (Klasse)
bekanntmachen.
Die Präprozessor-Direktive #include dient dazu, den Inhalt einer Datei in den
Quelltext einkopieren zu lassen. In C/C++ werden selbst Anfänger gleich mit
diesem Konzept konfrontiert, da man nur auf diese Weise auf die Funktionen/Klassen der Standardbibliothek zugreifen kann. Die Standardbibliotheken von C und
C++ liegen als kompilierte LIB-Dateien vor und enthalten die Definitionen einer
Reihe von nützlichen Funktionen (und Klassen). Um eine dieser Funktion in einem
Programm aufrufen zu können, muß man die Funktion zuvor per Deklaration beim
Compiler bekanntmachen.
Um dem Programmierer die Tipparbeit zu ersparen, sieht der ANSI-Standard eine
Reihe von Header-Dateien vor, in denen die Deklarationen der Bibliothekselemente
stehen. Jede Header-Datei ist einem speziellen Themengebiet gewidmet. Die Funktion printf() zur Textausgabe fällt beispielsweise in den Bereich Ein- und Ausgabe,
englisch Input/Output (IO), ihre Deklaration ist in der Header-Datei stdio.h enthalten. Statt printf() und weitere Funktionen zur Ein- und Ausgabe extra im
Programm vorab zu deklarieren, genügt es daher die Header-Datei stdio.h einzubinden:
#include <stdio.h>
Warnung
Gemäß ANSI-C lauten alle Header-Dateien für die C-Laufzeitbibliothek auf .h aus.
Gemäß ANSI-C++ haben die Header-Dateien dagegen keine Extension und den
alten C-Headern wird der Buchstabe c vorangestellt (cstdio statt stdio.h). Zudem
sind alle Bibliothekselemente in dem Namensbereich std deklariert. Die korrekte
Einbindung der Header-Dateien in C++, beispielsweise der Header-Datei iostream
mit den Stream-Klassen zur Ein- und Ausgabe, sähe damit wie folgt aus:
30
Ein- und Ausgabe
#include <iostream>
using namespace std;
Einige Compiler unterstützen derzeit aber auch noch ältere Versionen von iostream
oder haben die Stream-Klassen nicht im Namensbereich std deklariert. In solchen
Fällen muß man sich notgedrungen nach der vom Compiler vorgegebenen Syntax
richten, meist:
#include <iostream.h>
oder
#include <iostream>
Ein- und Ausgabe
printf() / scanf()
cout / cin
Beschreibung
Um mit dem Anwender interagieren zu können, muß ein Programm in der Lage sein, Informationen und Daten vom Anwender entgegenzunehmen und selbst Daten und Informationen über
den Bildschirm auszugeben.
Anwendung
Im Unterschied zu Sprachen wie Fortran oder Basic besitzt die Sprache C keine
eigenen Sprachelemente zur Ein- oder Ausgabe. Dies bedeutet nicht, daß mit Coder C++-Programmen keine E/A-Operationen durchgeführt werden können. Man
muß nur statt eines Schlüsselworts der Sprache eine passende Funktion der Laufzeitbibliothek aufrufen.
In C sind dies vor allem die Funktionen
●
printf() für die Ausgabe auf die Konsole (Bildschirm)
●
scanf() für das Einlesen von Tastatur.
In C++ bedient man sich der Klassen
●
cout (Ausgabe auf Konsole) und
●
cin (Einlesen von Tastatur)
und der Stream-Operatoren << und >>.
31
Grundlagen
Warnung
Die oben beschriebenen Funktionen und Klassen sind gemäß ANSI Teil der Standardbibliotheken von C/C++ und daher stets verfügbar. Der Austausch von Informationen zwischen Anwender und Programm über diese Funktionen und Klassen
ist allerdings auf Konsolenprogramme beschränkt. Programme mit grafischer
Benutzeroberfläche (GUI), die unter Windows, X-Windows oder OSF Motif laufen,
verwenden andere Möglichkeiten der Ein- und Ausgabe, die durch spezielle APIs
(Sammlungen von Funktionen und Klassen für bestimmte Programmieraufgaben)
unterstützt und implementiert werden.
Beispiele
Ein- und Ausgabe unter C:
#include <stdio.h>
int main()
{
int zahl1, zahl2;
/* Daten einlesen */
printf("Geben Sie zwei Zahlen zwischen 0 und 100 ein: \n\n");
scanf("%d %d", &zahl1, &zahl2);
fflush(stdin);
/* Daten ausgeben
puts("\n");
printf("1. Zahl =
printf("2. Zahl =
printf("Produkt =
return 0;
*/
%d\n", zahl1);
%d\n", zahl2);
%d\n", zahl1 * zahl2);
}
Ein- und Ausgabe unter C++:
#include <iostream>
using namespace std;
int main()
{
int zahl1, zahl2;
/* Daten einlesen */
cout << "Geben Sie zwei Zahlen zwischen 0 und 100 ein: \n\n";
cin >> zahl1 >> zahl2;
/* Daten ausgeben */
cout << endl;
cout << "1. Zahl = " << zahl1 << endl;
cout << "2. Zahl = " << zahl2 << endl;
32
Programmfluß
cout << "Produkt = " << zahl1 * zahl2 << endl;
return 0;
}
Programmfluß
C/C++-Programme bestehen aus einer Ansammlung von Deklarationen und Definitionen. Anweisungen findet man nur in Funktionen (in C++ auch in den Methoden
(Elementfunktionen) von Klassen). Damit stellt sich die Frage, mit welcher Anweisung die Ausführung eines Programmes beginnt.
●
●
●
●
Jedes C/C++-Programm beginnt mit der Hauptfunktion main(), die im Quelltext des Programms definiert sein muß.
Die Anweisungen in der main()-Funktion werden nacheinander ausgeführt.
Durch Aufruf einer Funktion aus einer anderen Funktion heraus, beispielsweise auch aus main(), kann der Programmfluß gesteuert und der Quellcode durch
Aufteilung auf mehrere Funktionen modularisiert werden.
Innerhalb einer Funktion kann der Programmfluß durch Verzweigungen (if,
switch) und Schleifen (for, while) gesteuert werden.
Warnung
Leser, die mit C/C++ für Windows programmieren wollen, seien darauf hingewiesen, daß Windows-Programme statt der main()-Funktion die Funktion WinMain()
verwenden. Je nach verwendetem Compiler und Klassenbibliothek kann WinMain()
selbst wieder durch eine andere Funktion (beispielsweise OwlMain() für Borland C++
mit OWL) oder eine Klasseninstanz (beispielsweise ein globales Objekt der MFCKlasse CWinApp in Visual C++) ersetzt sein.
Konsolenprogramme, die unter Windows ausgeführt werden (sprich im Fenster der
MS-DOS-Eingabeaufforderung ablaufen und über keine eigene Windows-Oberfläche verfügen), verwenden aber wie reine DOS- oder UNIX-Programme die main()Funktion.
Verweise
Siehe die Anschnitte zu Programmsteuerung, Funktionen, Exception-Behandlung.
33
Grundlagen
Programmerstellung
Beschreibung
Um aus einem in C/C++ formulierten Programmquelltext ein ausführbares Programm zu
machen, muß man es kompilieren. Bei der Kompilation wird der Programmquelltext vom Compiler in Maschinencode umgewandelt. In Zusammenarbeit mit dem Linker wird aus diesem
Maschinencode eine ausführbare Datei (unter Windows mit der Extension .exe) erzeugt, die
allerdings nur auf bestimmten Plattformen (Kombination aus Prozessor und Betriebssystem,
beispielsweise
Intel-kompatibler
Prozessor
und
Windows 95-Betriebssystem)
ausgeführt
werden kann.
Anwendung
Die Erstellung eines Programmes ist natürlich nicht mit der Eingabe des Quelltextes
in einen Editor abgeschlossen. Bevor ein Programm ausgeführt werden kann, muß
es in maschinenlesbaren Code umgewandelt werden. Besteht ein Programm aus
mehreren Modulen, müssen diese zusammengebunden werden. Diese Aufgaben
übernehmen der Compiler und der Linker.
1. Quelltext in Editor eingeben. Dies kann prinzipiell in jedem ASCII-Texteditor
geschehen. PC-Compiler verfügen meist über eine integrierte Entwicklungsumgebung (IDE) mit eigenem Editor, der mehr Unterstützung bei der Programmerstellung bietet.
2. Header-Dateien einkopieren. Zu Beginn der Kompilation wird der Quelltext mittels der #include-Direktive aufgeführter Header-Dateien in den Quelltext der Programmdatei kopiert.
3. Quelltextdateien kompilieren. Der Compiler übersetzt dann den Quelltext in maschinenlesbaren Objektcode. Der Objektcode ist meist an eine bestimmte Umgebung (Computerkonfiguration) angepaßt und nicht zwischen unterschiedlichen
Umgebungen portierbar. Syntaktische Fehler im Programm werden vom Compiler angezeigt und müssen korrigiert werden.
4. Objektcode-Dateien (.obj) und Bibliotheken (.lib) zusammenbinden. Besteht ein
Programm aus mehreren Quelltextdateien, werden diese vom Compiler einzeln in
Objektcode übersetzt. Dem Linker obliegt dann die Aufgabe, diese ObjektcodeDateien sowie den Objektcode der benutzten Bibliotheksfunktionen in eine Programmdatei (.exe unter Windows) zusammenzubinden.
5. Debuggen. Nach dem Kompilieren und Linken liegt ein ausführbares, aber selten
ein korrektes Programm vor. Bezüglich lauffähigen Programmen unterscheidet
man Laufzeitfehler, die sich meist durch Programmabstürze oder Endlosschleifen
äußern, und logische Fehler, wenn das Programm zwar läuft, aber nicht seinen
Zweck erfüllt. Zum Aufspüren dieser Fehler verwendet man üblicherweise einen
Debugger, mit dessen Hilfe man das Programm schrittweise ausführen und kontrollieren kann.
34
Programmerstellung
Ablauf der Programmerstellung
Die gängigsten Compiler
Der GNU-Compiler
Der GNU-Compiler ist ein frei verfügbarer Compiler, den man kostenlos aus dem
Internet beziehen kann (http://Sourceware.cygnus.com). Den GNU-Compiler gibt es
für UNIX wie für Windows.
Etwas unbequem für Windows-Anwender ist, daß der GNU-Compiler über keine
integrierte Entwicklungsumgebung verfügt, und man daher den Compiler explizit
aus der MS-DOS-Eingabeaufforderung heraus aufrufen muß.
1. Setzen Sie Ihren Quelltext mit einem beliebigen ASCII-Editor auf, und speichern
Sie die Datei.
2. Sofern Sie das /bin-Verzeichnis des Compilers in Ihren Pfad eingetragen haben, so
daß der Compiler gcc oder g++ von überall aufrufbar ist, wechseln Sie in das
Verzeichnis, in dem die Quelltextdatei steht.
3. Rufen Sie den C++-Compiler mit dem Dateinamen der Quelltextdatei auf:
g++ quelltext.cpp
oder
gcc quelltext.c
für den Aufruf des reinen C-Compilers.
Das fertige Programm lautet a.exe (a.out unter Unix) und kann direkt ausgeführt
werden.
35
Grundlagen
Wenn Sie möchten, können Sie auch einen expliziten Namen für die ausführbare
Datei angeben.
g++ quelltext.cpp -o progname
Programme, die aus mehreren Modulen bestehen, erstellen Sie durch Auflistung
aller beteiligten Quelldateien (#include-Dateien werden nicht aufgeführt).
gcc quelltext1.cpp quelltext2.cpp -o progname
Wenn Sie dem Compiler irgendwelche Optionen übergeben wollen (beispielsweise ansi für strikt ANSI-kompatiblen Code oder -c für Kompilieren ohne zu Linken),
setzen Sie diese hinter den Dateinamen.
gcc quelltext.cpp -ansi -c
Für die Erstellung der Windows-Programme müssen verschiedene Bibliotheken
explizit mit eingebunden werden:
gcc winprog.cpp -lkernel32 -luser32 -lgdi32
Welche weiteren Bibliotheken unter Umständen aufgenommen werden müssen, entnehmen Sie der Compiler-Dokumentation.
Warnung
Die neueste Version des GNU-Compilers heißt jetzt egcs.
Der Borland C++-Compiler
In der IDE (integrierten Entwicklungsumgebung) des Borland C++-Compilers werden Programme in Form von Projekten verwaltet. Konsolenanwendungen, die nur
aus einer Datei bestehen, können zwar ohne Projektverwaltung erstellt werden,
doch warum sollte man die angebotenen Möglichkeiten nicht nutzen.
1. Legen Sie ein neues Projekt an (Befehl Datei/Neu/Projekt für BorlandC++ 5.0, unter 4.5 befand sich der Befehl noch im Menü Projekt). Es erscheint der Target Expert, in dem Sie angeben können, welche Art von Anwendung Sie erstellen wollen.
2. Geben Sie das Projektverzeichnis und einen Namen für die ausführbare Datei an.
Wählen Sie als Zieltyp Anwendung, als Umgebung Win32 und als Zielmodell Konsole
(oder als Umgebung DOS, wenn Sie noch mit einem Win16-Betriebssystem arbeiten). Die weiteren Einstellungen werden für Sie angepaßt, achten Sie aber darauf,
daß die OWL nicht eingebunden wird.
3. Öffnen Sie eine neue Quelltextdatei. Klicken Sie im erscheinenden Projektfenster
auf den Knoten der .cpp-Datei. (Wurden weitere Knoten angelegt (.rc, .def) können Sie diese mit den Befehlen des Kontextmenüs löschen). Es erscheint ein
Editorfenster für die Quelltextdatei.
4. Geben Sie Ihren Quelltext ein und sichern Sie.
36
Programmerstellung
5. Rufen Sie den Compiler auf (Befehl Projekt/Projekt neu kompilieren für BorlandC++ 5.0).
6. Führen Sie das Programm aus (Befehl Debug/Ausführen für BorlandC++ 5.0). Unter
Win32 läuft das Programm in einem MS-DOS-Fenster ab, das sofort wieder
verschwindet, nachdem das Programm beendet wurde. Um dies zu verhindern,
können Sie die Beispielprogramme um einen Aufruf der Funktion getchar() vor
der return-Anweisung von main() erweitern. Das Programm wartet dann auf eine
Tastatureingabe, und das DOS-Fenster bleibt sichtbar.
Die Einstellungen für den Compiler und Linker werden in entsprechenden Dialogfeldern gesetzt (Befehl Optionen/Projekt für BorlandC++ 5.0).
Zur Erstellung von Windows-Programmen wählen Sie im Target Expert als Zieltyp
Anwendung, als Umgebung Win32 und als Zielmodell GUI (statt Konsole). Achten Sie
darauf, daß keine zusätzliche Klassenbibliothek (OWL, OCF, MFC, etc.) eingebunden wird, da in diesem Buch nur reine API-Programme beschrieben sind.
Der C++-Builder
Der C++Builder von Borland arbeitet ebenfalls mit einer Projektverwaltung. Während der C++Builder 1.0 die Projekte jedoch noch einzeln verwaltete, gibt es in der
Version 3.0 nun auch die Möglichkeit, mehrere zusammengehörende Projekte
zusammen in einer Projektgruppe zu verwalten (analog den Arbeitsbereichen in
Visual C++).
1. Legen Sie ein neues Konsolen-Projekt an (Befehl Datei/Neu für C++Builder 3.0). Es
erscheint ein mehrseitiges Dialogfenster, in dem Sie zur Seite Neu wechseln.
2. Doppelklicken Sie auf das Symbol Konsolen-Experte (Textbildschirm-Anwendung für 1.0).
3. Es erscheint direkt der Quelltexteditor des C++Builders mit einer extra Seite für
Ihren Quelltext. Speichern Sie Projekt und Quelltext (Befehl Datei/Alles speichern).
4. Geben Sie Ihren Quelltext ein – entweder indem Sie ihn in das vorgegebene Gerüst
einpassen oder indem Sie das vorgegebene Gerüst zuvor löschen und dann Ihren
Text eintippen.
5. Führen Sie das Programm aus (Befehl Start/Start). Unter Win32 läuft das Programm in einem MS-DOS-Fenster ab, das sofort wieder verschwindet, nachdem
das Programm beendet wurde. Um dies zu verhindern, können Sie die Beispielprogramme um einen Aufruf der Funktion getchar() vor der return-Anweisung von
main() erweitern. Das Programm wartet dann auf eine Tastatureingabe, und das
DOS-Fenster bleibt sichtbar.
37
Grundlagen
Die Einstellungen für den Compiler und Linker werden in entsprechenden Dialogfeldern gesetzt (Befehl Optionen/Projekt für C++Builder 1.0 oder Projekt/Optionen
für 3.0).
Zur Erstellung von Windows-Programmen doppelklicken Sie im Schritt 1 auf das
Symbol Anwendung statt auf Konsolen-Experte.
Warnung
Wenn Sie mit dem C++Builder 3 arbeiten, müssen Sie in Ihre Konsolenanwendungen unter Umständen auch die Header-Datei <condefs.h> aufnehmen.
Tip
Der große Vorzug des C++-Builders liegt in der RAD-Umgebung zur Entwicklung
von Windows-Programmen. RAD bedeutet Rapid Application Development und
steht für die visuelle, komponentenbasierte Erstellung von Programmen.
Der Visual C++-Compiler
Auch der Visual C++-Compiler von Microsoft arbeitet mit einer Projektverwaltung.
Zusätzlich werden in Visual C++ Projekte in Arbeitsbereichen verwaltet (auf diese
Weise können beispielsweise die Projekte für eine Windows-Anwendung und
etwaige unterstützende DLLs und LIBs zusammen in einem Arbeitsbereich verwaltet werden).
1. Legen Sie ein neues Konsolen-Projekt an (Befehl Datei/Neu ab Visual C++ 5.0). Es
erscheint ein mehrseitiges Dialogfenster, in dem Sie zur Seite Projekte wechseln.
2. Geben Sie einen Projektnamen ein, wählen Sie den Pfad aus, unter dem das Verzeichnis für die Quelldateien des Projekts eingerichtet wird, aktivieren Sie die Option Neuen Arbeitsbereich erstellen und doppelklicken Sie dann auf das Symbol
Win32-Konsolenanwendung. (In Visual C++ 6 erscheint daraufhin ein Dialogfenster,
in dem Sie neben einem leeren Projekt auch Projekte mit Datei und Grundgerüst
erstellen lassen können. Die nachfolgenden Schritte 3 und 4 erübrigen sich dann.)
3. Öffnen Sie eine neue Quelltextdatei (Befehl Datei/Neu, Seite Dateien ab Visual C++
5) Geben Sie einen Dateinamen ein, und doppelklicken Sie dann auf das Symbol
C++-Quellcodedatei.
4. Nachdem die Datei erstellt wurde, doppelklicken Sie im Arbeitsbereich-Fenster
(Seite Dateien) auf den gleichnamigen Knoten, um die Datei in ein Editorfenster
zu laden.
5. Geben Sie Ihren Quelltext ein und sichern Sie.
6. Kompilieren und linken Sie das Projekt (Befehl Erstellen/<ZIELDATEI> erstellen).
7. Führen Sie das Programm aus (Befehl Erstellen/Ausführen von <ZIELDATEI>).
38
Programmerstellung
Die Einstellungen für den Compiler und Linker werden in entsprechenden Dialogfeldern gesetzt (Befehl Projekt/Einstellungen ab VisualC++ 5.0).
Zur Erstellung von Windows-Programmen doppelklicken Sie im Schritt 1 auf das
Symbol Win32-Anwendung statt auf Win32-Konsolenanwendung.
39