C C++1-4 strukturierter ansatz - staff.hs-mittweida.dethiem1/cpp/unterlagen/kap01/theorie01.pdf · C/C++ kennt keine Prozeduren sondern nur Funktionen mit Wertübergabe (call-by-

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



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



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)



Entwicklung strukturierter und objektorientierter Programmiersprachen



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



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).



*.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



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>


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*/



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*/



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.



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);



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



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.



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);



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



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



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; }


#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.



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)




#include <iostream> //Deklaration von cin, cout

#include <iomanip> //Für den Manipulator setw()

#include <string>


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.



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;

}


/* E/A-Demo in C++ */

#include <iostream>


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



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!

Documents

C C++1-4 strukturierter ansatz - staff.hs-mittweida.dethiem1/cpp/unterlagen/kap01/theorie01.pdf · C/C++ kennt keine Prozeduren sondern nur Funktionen mit Wertübergabe (call-by-