Upload
nguyenthien
View
233
Download
0
Embed Size (px)
Citation preview
Die Programmiersprache
C/C++
Strukturierter Ansatz
Dr.-Ing. E. Thiem Datum: 15.02.2018
#include <iostream> using namespace std;
char Name[20]; void main(void) { cout<< "Gib Deinen Namen ein: "; cin>>Name; cout<< "Hallo "<<Name<<"\n" ; }
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 1 Strukturierter Entwurf
Gliederung 1 Die Sprache C/C++ ................................................................................................................... 3
1.1 Historie ............................................................................................................................... 3
1.2 Softwareentwickung in C und C++ .................................................................................. 5
1.2.1 Der Aufbau eines C/C++- Programms (Strukturierter Ansatz) ...................................... 5
1.2.2 Der Vergleich eines Programms in C, C++ und in Pascal ............................................ 8
1.3 Grundlegende Ein- und Ausgabefunktionen in C und C++ ........................................... 9
1.3.1 Ein- und Ausgabefunktionen in C ................................................................................. 9
1.3.2 Ein- und Ausgabefunktionen in C++: cin, cout und cerr .......................................... 15
1.4 Aufgaben zum Kapitel 1 ............................................................................................... 21
2 Sprachelemente von C und C++ ........................................................................................... 22
2.1 Elemente und Begrenzer ............................................................................................... 22
2.2 Datentypen ...................................................................................................................... 23
2.2.1 ganze Zahlen, Wahrheitswerte und Zeichen ............................................................ 24
2.2.2 Gleitkommazahlen ..................................................................................................... 26
2.2.3 Aufzählungstyp - enum (enumerate), 2 .. 4 Byte (je nach Compilerumgebung) ...... 28
2.2.4 Selbstdefinierte Typen ............................................................................................... 29
2.3 Variablenvereinbarungen ............................................................................................... 30
2.4 Konstantenvereinbarung ................................................................................................ 34
2.5 Ausdrücke ........................................................................................................................ 35
2.5.1 Operatoren – Arithmetische Operatoren .................................................................... 35
2.5.2 logische und bitweise Operatoren ............................................................................ 36
2.5.3 Vergleichsoperator ..................................................................................................... 38
2.5.4 Schiebeoperatoren ................................................................................................... 39
2.5.5 Inkrementieren und Dekrementieren (Eins-Erhöhung, Eins-Erniedrigung) ............... 39
2.5.6 Der Operator sizeof ................................................................................................... 40
2.5.7 Der Bedingungsoperator ? ........................................................................................ 40
2.5.8 Priorität der Operatoren ............................................................................................. 41
2.6 Aufgaben zu Kapitel 2.1 bis Kapitel 2.5 ........................................................................ 42
2.7 Strukturanweisungen...................................................................................................... 43
2.7.1 Bedingte Anweisung - Alternative .............................................................................. 43
2.7.2 Schleifenanweisungen ............................................................................................... 50
2.8 Sprung-Anweisungen ..................................................................................................... 56
2.8.1 Strukturierte Sprünge ................................................................................................. 56
2.8.2 goto-Sprünge ............................................................................................................. 57
2.9 Aufgaben zu Kapitel 2.7 und Kapitel 2.8 ....................................................................... 58
3 Strukturierung der C/C++-Programme ................................................................................. 60
3.1 Die Funktion .................................................................................................................... 60
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 2 Strukturierter Entwurf
3.1.1 Funktionsdefinition ..................................................................................................... 60
3.1.2 Liste einiger häufig gebrauchter Systemfunktionen ................................................... 65
3.1.3 Funktionsdeklaration (Prototyp) ................................................................................. 69
3.1.4 Rekursiver Funktionsaufruf ........................................................................................ 71
3.2 Felder (Arrays) ................................................................................................................. 72
3.2.1 Vereinbarung von Feldern ......................................................................................... 72
3.2.2 Zugriff auf Feldelemente ............................................................................................ 73
3.2.3 Zeichenketten ............................................................................................................ 75
3.3 Pointer (Zeiger) ................................................................................................................ 79
3.3.1 Der Datentyp Pointer ................................................................................................ 79
3.3.2 Initialisierung der Zeigervariablen .............................................................................. 81
3.3.3 Dynamische Speicherbereiche .................................................................................. 81
3.4 Strukturen ........................................................................................................................ 83
3.4.1 Strukturbeschreibung ................................................................................................. 83
3.4.2 Initialisierung und Zugriff auf Strukturen .................................................................... 84
3.4.3 unions ........................................................................................................................ 86
3.5 Zeiger als Parameter in Funktionen und auf Strukturen ............................................. 87
3.5.1 Funktionen ................................................................................................................. 87
3.5.2 Zeiger auf eine Struktur ............................................................................................. 92
3.5.3 Zeiger auf Funktionen ................................................................................................ 94
3.6 Aufgaben zum Kapitel 3 ................................................................................................ 95
4 Grundlagen der Dateiarbeit .................................................................................................. 97
4.1 File-Stream-Klassen ........................................................................................................ 97
4.2 Textdateien ...................................................................................................................... 98
4.3 Binärdateien .................................................................................................................. 101
Literatur…………………………………………………………………………………………………. 102
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 3 Strukturierter Entwurf
1 Die Sprache C/C++
1.1 Historie
Die Programmiersprache C wurde 1971 von Dennis M. Ritchie geschaffen und in den
Jahren 1973/74 von Brian W. Kernighan weiterentwickelt. Diese beiden US-
Wissenschaftler gelten als die „Väter“ der Sprache C.
B. Stroustrup - Mitarbeiter von AT&T - erweiterte die Sprache C mit objektorientierten
Eigenschaften Ende der 80-ziger Jahre. Er nannte seine Neuentwicklung „C mit
Klassen“. Der Name „C++“ wurde erst später benutzt. Das zugefügte „++“ soll dabei
an den C-Inkrementierungsoperator erinnern.
Die Stärke von C und C++ liegt in ihren vielen Operatoren und ihrer
Maschinennähe, die Schwäche liegt in der unzureichenden Überprüfung auf
Typverträglichkeit durch den Compiler. C und C++ enthalten Eigenschaften und
Sprachelemente des Assemblers für Maschinensprache und anderer strukturierter
Programmiersprachen. Aus der Maschinensprache stammen der Registerzugriff, die
Inkrement- und Dekrementoperatoren sowie die Behandlung von Zeigern als
Adressen, die man wie ganze Zahlen manipulieren kann. Sprachelemente höherer
Programmiersprachen sind Prozeduren, Schleifen, Datentypen, ... .
Zur praktischen Umsetzung der Sprache und zur effektiven Projektentwicklung sind
beginnend mit den Urversionen der beiden „Väter“ der Sprache C eine Reihe von
Entwicklungsumgebungen (Turbo C++ und Borland C++, Microsoft C++ und Visual
C++, GNU C++, Motif und Open GL, ...) für unterschiedliche Betriebssysteme (UNIX,
MS-DOS, MS-Windows, OS/2 ...) geschaffen worden. Im Betriebssystem UNIX mit
seinen verschiedenen Derivaten ist eine vernünftige Systemprogrammierung nur mit der
Sprache C/C++ möglich.
Elemente der Sprache C++ weitere Befehle + objekorientierter Ansatz
Elemente der Sprache C (1989-Nomienierung)
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 4 Strukturierter Entwurf
Entwicklung strukturierter und objektorientierter Programmiersprachen
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 5 Strukturierter Entwurf
1.2 Softwareentwickung in C und C++
1.2.1 Der Aufbau eines C/C++- Programms (Strukturierter Ansatz)
Präprozessoranweisungen oder
Konstantendeklaration Variablendeklaration Funktionsdefinitionen Anweisungsteil Hauptfunktion Anweisungsteil
const int k, l;
int i, j;
Funktion (Parameter)
{
Anweisung1;
Anweisung2;
...........
}
void main (void)
{
Anweisung1;
Anweisung2;
...........
}
# include <iostream>
using namespace std;
//für C++
# include <stdio.h>
//für C
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 6 Strukturierter Entwurf
Ein C-Programm beginnt mit der Auflistung der Präprozessor-Anweisungen -
mit # eingeleitet -, es folgen Vereinbarungen für Variable, Konstante, Datentypen und
Funktionen.
Daran schließt sich das Hauptprogramm an, durch main() gekennzeichnet und in { .. }
geklammert. Die geschweifte Klammer entspricht etwa dem begin...end aus TP.
Es können weitere Definitionen von Variablen, Konstanten, Datentypen und Funktionen
folgen.
Statt des := -Zeichens wird in C nur = geschrieben. Schleifen und Verzweigungen sind
in C ähnlich aufgebaut wie in Turbo-Pascal:
begin .. end { .. }
if .. then .. else if ( .. ) else
for .. do for ( .. )
while .. do while ( .. )
repeat .. until do .. while ( .. )
Ein in C geschriebenes Programm wird erst lauffähig, wenn folgende Arbeitsschritte
durchgeführt werden:
Mittels eines Text-Editors wird der Quelltext, der verschiedene Module (z.B. Header-
Dateien) enthalten kann, geschrieben (Dateierweiterung: C und CPP).
Der Präprozessor ergänzt den Quelltext um die in den Header-Dateien angegebenen
Funktionen.
Der Compiler übersetzt den gesamten Quelltext. Es entsteht eine Objektdatei
(Dateierweiterung: OBJ). Eine solche Objektdatei enthält neben dem erzeugten
Maschinencode noch weitere Informationen, wie z.B. Symboltabellen.
Der Linker verwendet alle diese Informationen, um den Code und die Daten in ihren
Bereichen zusammenzufassen. Ferner werden benötigte Funktionen (z.B. E/A) aus den
Bibliotheken in das Programm eingebunden. Es entsteht ein lauffähiges
Maschinenprogramm (Dateityp: EXE).
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 7 Strukturierter Entwurf
*.exe, *.com, *.dll
compile link start
edit header der objektlibraries (*.lib) dynamic link
C++-Umgebung (*.h) libraries (*.dll)
Header (Dateityp: h)
sind lesbare Textdateien, die durch einen include-Vorgang (Einfügen des Headertextes
in die Quelldatei) schnell häufig zu nutzende Befehls- oder Anweisungsfolgen
bereitstellen.
Objektlibraries (Dateityp: lib)
sind spezielle nicht lesbare Binärdateien, die bereits übersetzte Header- oder
Programmsequenzen enthalten, die ohne zeitaufwendige Compilierung mit
Anwenderobjekten durch den Linker verbunden werden können.
Dynamic link libraries (Dateityp: dll)
enthalten lauffähige Module, die nach dem Programmstart in der Systemumgebung
bereitstehen müssen und von dort in den Arbeitsspeicher geladen werden.
DLL’s können auch statisch in die ausführbare Datei geladen werden. In diesem Fall läuft
die stark vergrößerte EXE-Datei in jeder Betriebssystemumgebung.
C/C++ kennt keine Prozeduren sondern nur Funktionen mit Wertübergabe (call-by-
value). Durch Angabe eines Zeigers auf einen Parameter -statt des Parameters-
kann eine call-by-reference-Parameterübergabe (Variablenübergabe) erreicht
werden. Die Rückgabe des Funktionswertes und der Rücksprung erfolgt mittels return.
Quellmodule *.c, *.cpp, *.h, *cs
Objektmodule *.obj
Prozess Segmente im HS
Lademodule (Task)
*.exe, *.com, *.dll
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 8 Strukturierter Entwurf
1.2.2 Der Vergleich eines Programms in C, C++ und in Pascal
Pascal C C++
program Pascal_Demo
uses Crt;
var
Name: string[20];
begin
write('Gib Deinen Namen ein: ');
readln(Name);
writeln('Hallo ', Name);
end.
/* C Demo */
# include <stdio.h>
char Name[20];
int main(void)
{
fputs("Gib Deinen Namen ein:", stdout);
gets(Name);
printf("Hallo %s\n", Name);
return 0;
}
// C++ Demo
# include <iostream>
using namespace std;
char Name[20];
void main(void)
{
cout<< "Gib Deinen Namen ein: ";
cin>>Name;
cout<<"Hallo "<<Name<<"\n";
}
/* siehe später im Kap. 1.3.2 und 3.2.3 auch
Zeichenkette mit string*/
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 9 Strukturierter Entwurf
1.3 Grundlegende Ein- und Ausgabefunktionen in C und C++
1.3.1 Ein- und Ausgabefunktionen in C
In der Informationsdatei stdio.h sind bezüglich der Verbindungen stdin, stdout und stderr
unter anderem folgende Ein- und Ausgabefunktionen definiert:
Eingabe Ausgabe
zeichenweise getchar() putchar()
string gets() puts() oder fputs()
formatiert scanf() printf()
1.3.1.1 Zeichenweise E/A: getchar(), putchar()
getchar() Eingabe eines Zeichens mittels Tastatur. Die Eingabe ist gepuffert, d.h.
die Eingabe muss mit ET abgeschlossen werden. Die Rückgabe von
getchar() wird als int geliefert. In C können Zeichen in char- und int-
Variablen abgelegt werden.
putchar() Ausgabe eines Zeichens auf dem Bildschirm.
Als Parameter wird ein Integer – oder der Zeichentyp char verwendet.
Beispiele in C: char c;
c = getchar();
Beispiele in C: putchar('A'); /* Es wird der Buchstabe ’A‘ ausgegeben*/
putchar('\n'); /* \n bewirkt einen Zeilenvorschub */
putchar('\0x34'); /*Die hexadezimale Zahl 0x34 stellt die Zahl
4 dar.*/
putchar('\007') /* Ausgabe des Signals BEL*/
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 10 Strukturierter Entwurf
Beispiele in C: char Name[20];
gets (Name);
Beispiele in C: char str[ ] = "Zeichenkette“;
puts (str);
puts ("TEST");
Beispiele in C: putchar('C'); //Ausgabe von C
putchar('\007'); //Steuerzeichen (BEL), oktal (Null für oktal)
putchar('\x41'); //Codeangabe für A, (x für hexadezimal)
putchar('\n'); //Zeilenvorschub
Bei nicht darstellbaren Zeichen (z.B. BEL) muss die ASCII-Darstellung gewählt werden.
Für häufig benötigte Sonderzeichen wurden Ersatzdarstellungen definiert:
Ersatz-zeichen
Wirkung Ersatz- zeichen
Wirkung
'\a'
'\b'
'\f'
'\n'
'\t'
Klingelzeichen
Rückschritt
Seitenvorschub
Zeilenende
horizontaler Tabulator
'\\'
'\''
'\"'
'\0oo' '
\xhh'
'\0'
umgekehrter Schrägstrich
Hochkomma
Anführungszeichen
oktal (mit Null beginnend)
Zeichen hexadezimal (mit x beginnend)
Textende Zeichen
1.3.1.2 Text- bzw. String-Ein/Ausgabe: gets(), puts(), fputs()
gets(); Die Funktion gets ermöglicht die Eingabe einer Zeichenkette.
puts("Hallo"); Die Funktion puts gibt den Inhalt einer Zeichenkette auf den
Bildschirm aus. Es wird automatisch ein Zeilenvorschub
durchgeführt.
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 11 Strukturierter Entwurf
Beispiele in C: fputs("Hallo\n", stdout);
puts("Hallo", stdout);
Aufbau des Formatelements: % [F] [z1] [.] [z2] [L] U
fputs() allgemeine Textausgabefunktion ohne Zeilenabschluss.
Der Name der Verbindung (stdout, stderr) muss als 2. Parameter
angegeben werden.
1.3.1.3 Formatierte Ausgabe: printf() (print formatted)
Die Funktion printf ermöglicht die Darstellung von Werten aller Standardtypen. Über
Formatanweisungen wird die Darstellung beeinflußt.
Ausgabe von Text und Zahlen (in dezimaler, oktaler oder hexadezimaler Darstellung).
Der erste Parameter muss ein Text sein (" "). Dieser Text (der Steuerstring) wird von
der Funktion printf() interpretiert: Enthält dieser Text nur Buchstaben und Ziffern, so
wird dieser Text ausgegeben.
Enthält dieser Text ein % -Zeichen (Fluchtsymbol), wird dieses als Beginn eines
Formatelementes interpretiert. Ein Formatelement beginnt immer mit dem Fluchtsymbol
% und endet mit einem Darstellungssymbol (d für dezimal, o für oktal, x für
hexadezimal, s für String). Zwischen Flucht- und Darstellungssymbol können Angaben
zur Darstellungsgröße, zu Füllzeichen und zu Nachkommastellen stehen.
Beispiele in C: printf("Hallo Hallochen\n");
printf("Darstellung der Zahl 99 als Dezimalzahl: %d", 99);
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 12 Strukturierter Entwurf
Symbol Bedeutung
[ ]
%
F
z1
.z2
L
U
optionale Angabe
Fluchtsymbol
Ausrichtung: Ohne Angabe: rechtsbündige Ausgabe
Minuszeichen: linksbündige Ausgabe
Größe des Ausgabefeldes, Stelligkeit:
Beginnt die dezimale Angabe mit 0, so wird als Füllzeichen 0 verwendet, Standard: Leerzeichen
Nachkommastellen (bei Text: die maximale Länge)
Trennzeichen, falls z1 und z2 verwendet wird
Long-Ausgabe (Ausgabe einer long int-Variablen)
Umwandlungszeichen, Darstellungssymbol
Damit wird die gewünschte Darstellung und der Datentyp angegeben.
Dieses Umwandlungszeichen muss zum übergebenen Parameter passend sein.
Gebräuchliche Umwandlungszeichen sind:
i oder d für ganze Zahlen mit Vorzeichen
s für Texte,
u unsigned (d.h. vorzeichenlos), dezimal, ohne VZ
f für Fließkommazahlen
o oktal
x oder X hexa
e Exponentialdarstellung
c Zeichen
p Pointer, Adresse
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 13 Strukturierter Entwurf
Beispiele in C: Projek t öffnen
float f = 12300.99800;
printf (" %f ", f); /* Standardausgabe 12300.99800 */
printf (" %.2f ", f); /* es werden nur 2 Stellen nach dem Komma
angezeigt. 12301.00 */
Weitere Beispiele in C:
printf("\nInteger: \t \t %10d ", 123);
printf("\nLinks: \t \t %-10d ", 456);
printf("\nNullen: \t \t %010d ", 789):
printf("\nGleitk.: \t \t %10.3f ", 12.3456);
printf (“Ausgabe von: %d %f %c“ , 10, 12.00, ‘A‘);
Typ Datentyp Beispiel Ausgabe
d int printf (“%d“, 100) 100
x Int – Ausgabe hexadezimal printf (“%x“, 100) 64
f Gleitkomma im Format (-) printf (“%f“, 123.12) 123.120000
6.2f Gleitkomma im Format float ##.## printf (“%6.2f“, 123.12) 123.12
E Gleitkomma im Format (-)x.xxE(±)xx printf (“%E“, 123.12) 1.231200E+02
c Zeichen printf (“%c“, ‘A‘) A
s Zeichenkette printf (“%s“, “Zeichenkette“) Zeichenkette
%-20s Zeichenkette linksbündig (20 Stellen) printf (“%-20s“, “Zeichenkette“)
%20s Zeichenkette rechtsbündig printf (“%20s“, “Zeichenkette“)
% Das Zeichen % selbst printf (“%%“) %
Formatierung der Anzeige von Gleitkommazahlen
Durch die Angabe eines Punktes hinter dem Formatierungszeichen %, kann die Anzahl
der Nachkommastellen festgelegt werden.
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 14 Strukturierter Entwurf
Beispiel in C:
int ganz; /* Variable ganz, vom Typ integer */
float komma; /* Variable komma, Typ real */
char zk[20]; /* Feld zk, von 20 Zeichen Länge */
scanf("%d" , & ganz);
scanf("%f" , & komma);
/* aber: */ scanf("%s" , zk); /* es handelt sich um ein Feld */
1.3.1.4 Formatierte Eingabe: scanf()
Diese Eingabefunktion ist das Gegenstück zu printf(). Sie verwendet auch einen
Steuerstring und weitere Parameter. Der Steuerstring legt die Art und Weise der
Eingabebehandlung fest. Bei der Eingabe von Variablen wird dem Namen der
Variablen ein & vorangestellt, handelt es sich um ein Feld, wird das &-Zeichen nicht
geschrieben.
Aufbau des Formatelementes: % [*] [Z] [L] U
Symbol | Bedeutung
% | Fluchtsymbol
* | Wegwerfen (überlesen)
z | Größe des Eingabefensters
L | long (bei long int und bei double)
U | Umwandlungszeichen (siehe printf)
Weiteres Beispiel in C:
int i;
float f;
char c;
char str[100];
scanf ("%c %i %f", &c, &i, &f);
scanf ("%s ", str);
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 15 Strukturierter Entwurf
1.3.2 Ein- und Ausgabefunktionen in C++: cin, cout und cerr
Mit der Entwicklung von C++ wurde ein neues Ein-/Ausgabe-System auf der Basis von
Klassen implementiert. Es entstanden die I/O-Stream-Klassen, die in der iostream-
Bibliothek, zur Verfügung stehen.
Die Klasse ios stellt die grundlegende Funktionalität für die Formatierung der Daten zur
Verfügung. Dazu werden eine Reihe von Flags definiert, die festlegen, wie z.B. Zeichen
bei der Eingabe interpretiert werden.
Die Informationsdatei iostream.h definiert die E/A-Funktionen cout, cin und cerr.
IOStream steht für Ein-/ Ausgabestrom, d.h. die Ein- und Ausgabe wird mit „Bit-Strömen“
organisiert:
cin >> <Var> Objekt der Klasse istream für Standardeingabe (meist Tastatur) cout << <Var> Objekt der Klasse ostream für Standardausgabe (meist Bildschirm)
cerr << <Var> Objekt der Klasse ostream zur ungepufferten Fehlerausgabe
(meist Bildschirm)
Bei der Programmiersprache C++ erspart, durch die Verwendung von Namensräumen
(using namespace std;) das std:: vor cout bzw. vor cin zu setzen.
ios
istream
iostream
ostream
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 16 Strukturierter Entwurf
Beispiel in C++: Projekt öffnen
#include <iostream> # include <iomanip> using namespace std; int main(void) { double x = 12.45; cout.precision(2); // Genauigkeit 2 Stellen cout << "Standard: "<< x << endl; return 0; }
1.3.2.1 Formatierung mit Manipulatoren für cout und cin
Manipulatoren Wirkung
setw(n) setzt die Feldweite auf n
hex, oct, dec Zahlenbasis (für Ganze Zahlen)
endl '\n' und flush
ends '\0'
setprecision(n) setzt die Anzahl der signifikanten Stellen auf n (für Gleitpunktzahl)
fixed Darstellung als Festpunktzahl
setfill(char) setzt das Füllzeichen
Methoden Wirkung
int precision (int n); setzt die Genauigkeit auf n (für Gleitpunktzahl)
setprecision(n) rundet das Ergebnis kaufmännisch.
Die Operatoren >> und << formatieren ihre Ein- bzw. Ausgabe gemäß den Einstellungen
der Flags in der Basisklasse ios.
Der Manipulator fixed ist eine Funktion, die die Methode cout.setf(ios::fixed); aufruft.
Der Einsatz von Manipulatoren ist deutlich einfacher als die direkte Veränderung der
Flags mit den Methoden setf() und unsetf().
Formatierte Ausgabe von Gleitpunktzahlen
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 17 Strukturierter Entwurf
Beispiel in C++:
#include <iostream> #include <iomanip> using namespace std; void main (void) { int c = 27, d = 26; float f = 3.1415927872; cout << setw(15) << "Hexadezimal: " << setfill('#') << setw(10) << hex << c << "," << setw(8) << d << endl; cout << setw(15) << setfill(' ') << "Float: " << setfill('.') << setw(10) << setprecision(2) << f << endl; }
Beispiel in C++: Projekt öffnen
#include <iostream> #include <iomanip> using namespace std; void main (void) { cout<< "|" << setw(6) <<"X" <<"|"; //Ausgabe: | X| X im Feld der Breite 6 cout << fixed << setprecision(2) << setw(10)<<123.4 << endl <<"1234567890"<< endl; //Ausgabe: 123.40 Feldbreite 10 1234567890 }
Ausgabe in Feldern
Manipulator Wirkung
setw (int n) setzt die Feldbreite auf n
left linksbündige Ausgabe im Feld
right rechtsbündige Ausgabe im Feld
internal Vorzeichen linksbündig, Wert rechtsbündig im Feld
Methoden Wirkung
int width (int n); setzt die Feldbreite auf n
Hinweis: Der Manipulator setw() ist in der Header-Datei iomanip deklariert.
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 18 Strukturierter Entwurf
Beispiel in C++ mit Setzen von Flags:
Projekt öffnen
# include <iostream> # include <iomanip> //setf(), setw(), setpresion() using namespace std; void main (void) { float kommazahl =1.250552; cout.setf(ios::fixed, ios::floatfield); // Setzen von Gleitkommaausgabe cout << setw(10) <<setprecision(2)<< kommazahl<<endl; // 10 Stellen insgesamt, 2 Stellen nach dem Komma // oder cout.width(10); cout.precision(2); cout << kommazahl<<endl; }
1.3.2.2 Formatierung mit IOS-Flags
Weitere Alternativen zu den vorhin vorgestellten Möglichkeiten:
cout.setf(<flags>)
mehrere Flags werden mit | verknüpft
zurücksetzen der Flags mit cout.unsetf(<flags>) oder
Mögliche IOS-Flags:
ios::left linksbündig
ios::right rechtsbündig
ios::scientific verwende Gleitpunktnotation (z.B. 1.2E+23)
ios::showpoint erzwinge einen Dezimalpunkt
ios::fixed verhindere die Verschiebung des Dezimalpunkts
ios::showpos zeige Vorzeichen von pos. Zahlen an
ios::uppercase verwende Großbuchstaben bei Zahlen (z.B. 1F)
ios::showbase gebe die Zahlenbasis aus (z.B. 0x1F)
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 19 Strukturierter Entwurf
Beispiel in C++: Projekt öffnen
#include <iostream> //Deklaration von cin, cout
#include <iomanip> //Für den Manipulator setw()
#include <string>
using namespace std;
int main(void)
{
string bezeichnung; // erzeugt einen leeren String, siehe auch Kapitel 1.3.2 double preis;
cout << "\nGeben Sie die Artikelbezeichnung ein: ";
//höchstens 15 Zeichen für die Bezeichnung einlesen:
cin >> setw(16);
cin >> bezeichnung;
cin.sync(); //Puffer leeren
cin.clear(); //evtl. gesetzte Fehlerflags löschen
cout << "\nGeben Sie den Artikelpreis ein: ";
cin >> preis; // Preis einlesen
// Kontrollausgabe
cout << fixed << setprecision(2)
<<"\n Artikel:"
<<"\n Bezeichnung: " << bezeichnung
<<"\n Preis: " << preis << endl;
cin.get ( ); //wartet auf ENTER-Eingabe
return 0;
}
Formatierte Eingabe
Durch die Verwendung des Datentyps string wird das Reservieren des notwendigen
Speichers, seine gegebenenfalls notwendige Erweiterung vereinfacht und damit
Speicherlecks und Überschreibung des reservierten Speicherbereiches verhindert.
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 20 Strukturierter Entwurf
1.3.3 Gegenüberstellung der Ein- und Ausgabefunktionen eines Programms in C, C++ und in Pascal
Beispiel in Pascal:
program Ein_u_Ausgabe_Demo;
var
i: integer;
r: real;
s: string[20];
begin
write('ganze Zahl: '); readln(i);
write('Kommazahl: '); readln(r);
write('Text: '); readln(s);
writeln('i = ', i, ' r = ', r, ' s = ', s);
end.
Beispiel in C: Projekt öffnen
/* E/A-Demo in C */
#include <stdio.h>
int i;
float r;
char s[20];
int main(void)
{
printf( "ganze Zahl: "); scanf(" %i" , & i) ;
printf("Kommazahl: "); scanf(" %f", & r) ;
printf("Text: "); scanf("%s", s) ;
printf("\ni = %i r = %f s = %s\n",i,r,s) ;
return 0;
}
Beispiel in C++: Projekt öffnen
/* E/A-Demo in C++ */
#include <iostream>
using namespace std;
int i;
float r;
char s[20];
void main(void)
{
cout << "ganze Zahl: "; cin >> i;
cout <<"Kommazahl: "; cin >> r;
cout <<"Text: "; cin >> s;
cout << "\ni = " << i << " r = " << r << " s = "
<< s << endl;
}
g a n z e Z a h l : 1 2 3 4 K o mm a z a h l : 5 . 6 7 8 T e x t : 1 2 3 4 5 6 7 8 9 i = 1 2 3 4 r = 5 . 6 7 8 s = 1 2 3 4 5 6 7 8 9
C/C++ Programmierung
Dr. E. Thiem C/C++ Konsolenprogrammierung 21 Strukturierter Entwurf
1.4 Aufgaben zum Kapitel 1
1. Erläutern Sie den prinzipiellen Programmaufbau eines C/C++-Programmes.
2. Was ist der Präprozessor bezüglich der Sprache C/C++?
3. Erklären Sie die besondere Bedeutung der Header-Dateien!
4. Zu welchem Zeitpunkt der Bearbeitung werden die objekt libraries und zu welchem
Zeitpunkt die dynamic link libraries benötigt? Welche Bibliotheken werden vom
Entwickler und welche vom Anwender der Software gebraucht?
5. Erklären Sie die Aufgabe des Linkers! Erklären Sie den Unterschied einer statischen
und einer dynamischen Modulbindung! Definieren Sie den Begriff
Laufzeitumgebung!
6. Erklären Sie die Bedeutung der folgenden Zeichen in C/C++: {, }, //, /*, */, #, ;, <<, >> !
7. Schreiben Sie ein C++-Programm! Über Tastatur sind 5 Temperaturwerte in °C
einzugeben! Stellen Sie folgende Ergebnistabelle für die Temperaturwerte auf dem
Bildschirm dar:
Temperaturwert-Nr. °C Kelvin Fahrenheit
1 22,2 2 -29,334 3 100,001 4 1.299,02 5 -0,04523
Versuchen Sie, die Tabelle für die verschiedenartigsten Werte möglichst exakt
kommastellengenau darzustellen!