C++ Programmierung 1 Jahr

01.09.
2003
Programmierung
Klasse IA02
© by Sebastian Wetzel
©-=]ToT[=-Acid Burn
1
01.09.2003
Erstellen eines C Programms

Jede moderne problemorientierte Sprache stellt ihnen mehrere Dienstprogramme im Rahmen
einer Entwicklungsumgebung (IDE) zu Verfügung.
Dienstprogramme: - Editor (Quelltext des Programms schreiben (Quellcode) )

Es entsteht eine Datei mit der Endung (erstes.cpp)
- Compiler (übersetzen des Quelltextes in eine Maschinen nahe Form)

wird auch als Objektcode bezeichnet (es entsteht eine neue
Datei erstes.obj)
- Linker (dem Programm werden notwendige Funktionen hinzugefügt und

ein lauffähiges Programm wird erzeugt (es entsteht eine neue
Datei erstes.exe)
Konsolenanwendung in der IDE erstellen

1. Schritt
VC starten
2. Schritt
Arbeitsbereich und ein Projekt anlegen
- Menübefehl Datei/ Neu aufrufen

- Seite Projekt anzeigen lassen
- Pfad auf H:\ umstellen
- Name für das Projekt eingeben
- Projekttyp Win32- Konsolenanwendung auswählen
- OK drücken
3. Schritt
Auswählen der Option EIN Leeres Projekt
- Fertigstellen Drücken
- OK drücken
4. Schritt
Aufnehmen einer Quelltextdatei in das Projekt
- Menübefehl PROJEKT / DEM PROJEKT HINZUFÜGEN / NEU aufrufen

- Seite Datei anzeigen lassen
- Name der Datei eingeben
- Dateityp C++ Quellcode auswählen
- OK drücken
2
01.09.2003
5. Schritt
Quelltext eingeben und Datei speichern
6. Schritt
Programm erstellen lassen
- Menübefehle ERSTELLEN / Name.exe erstellen

Treten Fehlermeldungen auf, zurück zum 5. Schritt
7. Schritt
Programm ausführen lassen
Befehl ERSTELLEN / AUSFÜHREN VON Name.exe

(Tastaturkürzel: Strg + F5)
Eigenschaften von C++
C++ C
- universell
- effizient
- maschinennah
- portabel
OOP
- Datenabstraktion
- Datenkapselung
- Vererbung
- Polymorphy
3
01.09.2003
8-Bit-System
Dual 27 26 25 24 23 22 21 20
128 64 32 16 8 4 2 1
BJ. 7 6 5 4 3 2 1 0 Erg.
0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1
0 1 0 1 1 0 0 1 89
Umwandlung Dezimalzahl in Dualzahl

Man dividiert fortlaufend die Dezimalzahl durch 2 und notiert sich den Rest der Division.
Abbruch wenn der Quotient null ist.
Die gesucht Dualzahl ergibt sich aus dem Rest der einzelnen Division wobei links der letzte
Divisionsrest steht.
Beispiel:
54:2=27 R0
27:2=13 R1
13:2=6 R1
6 : 2=3 R0
3 : 2=1 R1
1 : 2=0 R0
Ergebnis: 00110110
4
01.09.2003
Bilden einer negativen Dualzahl

1.Schritt
Man bildet die Dualzahl des Betrages der negativen Dezimalzahl
2.Schritt
1ner Kompliment bilden.
3. Schritt
+1 rechnen
Grundgerüst eines C++ Programms
#include <iostream> // einbinden der Bibliotheken

// Möglichkeit zur Ein- und Ausgabe
using namespace std;

void main ( ) // Hauptfunktion Main ()
{ // Blockbegrenzer
cout <<“Hallo Visual C++!!!!“; // Anweisung zur Textausgabe
} // Blockbegrenzer
Allgemeines zu Programmen in C++

Quellcode Dateien haben die Dateiendung cpp
Die Funktion Main() muss in jedem ausführbaren Programm genau 1mal vorkommen.
C++ unterscheidet streng zwischen Groß- und Kleinschreibung.
Syntax der Kommentare

Kommentare beginnen mit einem doppelten Schrägstrich // und enden am Zeilenende.
// Dies ist ein Kommentar

Kommentare über mehrere Zeilen beginnen mit dem zeichenpaar /* und enden mit */
/* Kommentar über
mehrere
Zeilen */
5
01.09.2003
Variablen und Konstanten

Deklaration und Definition
<Datentyp> Bezeichner;
z.B. int var1;
Variablennamen können in C++ 32 Zeichen lang sein. Bei der Vergabe eines Bezeichners ist
folgendes zu beachten:
• Gültige Zeichen sind A-Z, a-z, 0-9 und der Unterstrich_. Umlaute (ä, ö, ü usw.)
sind als Bestandteil von Variablennamen nicht gestattet.
• Variablennamen dürfen nicht mit einer Ziffer beginnen.
• Schlüsselwörter von C++ (int, switch, usw.) dürfen nicht als Variablennamen
verwendet werden.
• Variablennamen sollten nicht mit einem oder zwei Unterstrichen beginnen
Ganzzahl- Variablentypen
Typ Speicheraufwand in Bit Wertebereich

Int 16 -32768 bis 32767
Long 32 -2147483648- 2147483648
Char 8 -128 bis 127 und ASCII
Zeichen
Alle Ganzzahlen- Variablentypen kann man auch als unsigned Typen (Vorzeichenlos)
verwenden. Ihr Wertebereich verdoppelt sich so im Bereich der positiven Zahlen.
z.B. unsigned int var2; //Bereich von 0 bis 65535
Fließkommatypen
Typ Genau Bit Wertebereich

Float 7 32 3,4*10-38 bis 3,4*1038
Double 15 64 1,7*10-308 bis1,7*10308
Long double 19 80 3,4*10-4932bis3,4*104932
Variablen können an jeder beliebigen Stelle im Programm festgelegt werden. Variablen, die
an vielen Stellen der Funktion eingesetzt werden, sollten besser am Anfang der Funktion
festgelegt werden.
Der Datentyp der Variablen legt den Speicheraufwand, den Wertebereich und die Operatoren,
welche auf die Variable angewendet werden dürfen fest.
Eine Variable ist nur in dem Block in welchen sie definiert wurde bekannt.
6
01.09.2003
Initialisierung von Variablen

Variablen können bei ihrer Definition gleichzeitig initialisiert werden. (d.h. sie erhalten sofort
eine Wertzuweisung)
z.B. int zahl =12; //zahl erhält Anfangswert 12

char zeichen =’A’ // Zeichen erhält Anfangswert ’A’
Konstanten
Definition
const Typ NAME= Wert; // Attribut const legt fest das sich der Wert der
// Variablen NAME während des gesamten Programms nicht
// ändern wir
z.B. const double PI= 3.14259265 ;
Operatoren
Arithmetische Operatoren
Operation Operationszeichen
Addition +
Subtraktion -
Multiplikation *
Division /
Diese Operatoren sind sowohl auf Ganzzahlen als auch auf Gleitkommazahlen anwendbar.
Eine Ausnahme bildet der Modulo Operator.
Operationszeichen: %
Rest bei der Ganzzahligen Division.
Vorrangregeln sind wie in der Mathematik Punktrechnung vor Strichrechnung.

Höchste Priorität ( )- Klammern.
Sind die Operatoren gleichrangig wird von Links nach rechts aufgelöst.
7
01.09.2003
Man Beachte:
• Sind die Operatoren ganzzahlig so ist auch das Ergebnis ganzzahlig
z.B. 1 / 4=0
• Ist ein Operand ganzzahlig und der andere eine Gleitkommazahl so ist das Ergebnis
eine Gleitkommazahl
z.B. 1.0 / 4=0.25
Berechnung von Ausdrücken

24 / 7+3*2 =9
6-4 / 5+4.0 /2=8.0
1 / 3*2*4=0
5%*3-2*8=-13
a+b = (a+b)/(2*c)
2c
h
Π r2 3 = Π*r*r*h/3
Vergleichsoperatoren
Operation Operationszeichen
größer als >

kleiner als <
Gleichheit ==
ungleich !=
kleiner gleich <=
größer gleich >=
Das Ergebnis eines Ausdruckes mit einem Vergleichsoperator ist entweder wahr (Wert=1)
oder falsch (Wert =0). Die Vergleichsoperatoren haben einen geringeren Rang als die
Arithmetischen Operatoren.
Bsp.
a=4 b=7 c=5
a<=b 1
b>c<a 1
a= =b 0
5*a<7*b= =0 0
8
01.09.2003
Logische Operatoren
Logische Operatoren Verknüpfen in der Regel Ausdrücke welche aus Vergleichsoperatoren
bestehen.
Zeichen
UND- Operator &&
Verg.1 Verg.2 UND

0 0 0
0 1 0
1 0 0
1 1 1
ODER- Operator ||
Verg.1 Verg.2 ODER

0 0 0
0 1 1
1 0 1
1 1 1
Vereinung !
Verg. !
0 1
1 0
Rangfolge:
1. !
2. &&
3. ||
Zuweisungs- Operator =
Dieser Operator kann nur verwendet werden wenn auf der linken Seite eine Variable steht
welche den Ausdruck der Rechten Seite aufnehmen kann.
9
01.09.2003
Ausgabe mit cout

Cout ist ein Objekt, welches eine einfache Möglichkeit bietet, Daten z.B. auf dem Bildschirm
auszugeben. Eine Ausgabe erfolgt indem der Einfügeoperator << die Daten an cout schickt.
Beispiel für Daten:
• Zeichenkonstanten „Dies ist ein Text“
• Zeichen ‚A’
• Variablen Bezeichner angeben
• Manipulatoren - endl bewirkt Zeilenvorschub
- setw(n) bewirkt, dass nachfolgende Zahl, Zeichenkette mit
einer Breite von n Zeichen ausgegeben wird
- hex, oct, dec bewirken, dass die nachfolgenden Zahlen in der
Zahlendarstellung ausgegeben wird.
Hinweis: Für den Manipulator setw() muss die Bibliothek <iomanip.h> eingebunden werden.
Eingabe mit cin

Das Objekt cin wir zusammen mit dem Einleseoperator >> verwendet und schickt die
Eingabe in die nachfolgende Variable.
z. B. cin>>Test; //Test erhält Wert der Eingabe
Das Einlesen von mehreren Variablen, muss über mehrere Einleseoperatoren erfolgen.
Aufgabe:
Lesen Sie von der Tastatur 3 ganze Zahlen ein. Geben Sie anschließend diese Zahlen als
Dezimal-, Octal- und Hexadezimalzahl auf dem Bildschirm in folgender Tabellenform aus.
Programm:
#include <iomanip.h>
#include <iostream.h>
void main( )
{
int a, b, c;
cout<<" Bitte geben sie eine Zahl ein!";
cin>> a;
cout<<" Bitte Geben sie ein weitere Zahl ein!!!";
cin>> b;
cout<<" Bitte noch mal eine Zahl ein!";
cin>>c;
cout<<endl;
cout<<setw(20)<<"Hex"<<setw(20)<<"Dez"<<setw(20)<<"Oct"<<endl;
10
01.09.2003
cout<<hex<<setw(20)<<a;
cout<<dec<<setw(20)<<a;
cout<<oct<<setw(20)<<a<<endl;
cout<<hex<<setw(20)<<b;
cout<<dec<<setw(20)<<b;
cout<<oct<<setw(20)<<b<<endl;
cout<<hex<<setw(20)<<c;
cout<<dec<<setw(20)<<c;
cout<<oct<<setw(20)<<c<<endl;
Programmanalyse:
Typ: int
Bezeichner: a,b,c
Ablauf: Überschrift: Ausgabe ganzer Zahlen

Eingabeaufforderung : Bitte 3 ganze Zahlen eingeben.
Einlesen: a, b, c
Aufgabe:
Kreisesberechnung:
Der Nutzer ist nach Ausgabe einer Überschrift aufzufordern den Radius eines Kreises in cm
einzugeben. Anschließend ist der Umfang und der Flächeninhalt des Kreises zu berechnen
und auszugeben.
Programmanalyse:
Daten (Variablen Konstanten):
Konstant: PI double
Variable: Radius, Umfang, Flächeninhalt double
Ablauf:
1. Ausgabe: Überschrift (Kreisberechnung)
2. Ausgabe: Eingabeaufforderung
3. Einlesen: Radius
4. Berechnung: Umfang
5. Berechnung: Flächeninhalt
6. Ausgabe: Umfang, Flächeninhalt
11
01.09.2003
Programm:
#include<iomanip.h>
#include<iostream.h>
const double PI=3.141592654;
void main()
{
double radius, umfang, flaecheninhalt ;
cout<<"Kreisberechnung"<<endl;
cout<<"Bitte den Radius in cm eingeben!!"<<endl;
cin>>radius;
//Berechnung Umfang
umfang=2*PI*radius;
cout<<"Umfang= "<<umfang<<"cm"<<endl;
//Berechnung Flächeninhalt
flaecheninhalt=PI*radius*radius;
cout<<"Flächeninhal= "<<flaecheninhalt<<"cm²";
Aufgabe:
Lesen Sie 2 Ganze Zahlen ein und geben Sie anschließend alle Aufgaben und Ergebnisse für
die arithmetischen Operatoren aus.
z.B. Addition: z1+z2
Program:
#include <iostream.h>
#include <iomanip.h>
void main()
{
int z1,z2,za,zs,zm,zd,zmo;
cout<<"Rechenoperation"<<endl;
cout<<"Bitte geben Sie eine Ganzzahl ein!!!"<<endl;
cin>>z1;
cout<<"Bitte geben Sie noch eine Ganzzahl ein!!"<<endl;
12
01.09.2003
cin>>z2;
//Addition
za=z1+z2;
//Subtraktion
zs=z1-z2;
//Multiplikation
zm=z1*z2;
//Division
zd=z1/z2;
//Modulo
zmo=z1%z2;
cout<<"Additon= "<<z1<<"+"<<z2<<"="<<za<<endl;
cout<<"Subtraktion= "<<z1<<"-"<<z2<<"="<<zs<<endl;
cout<<"Multiplikation= "<<z1<<"*"<<z2<<"="<<zm<<endl;
cout<<"Diviosion= "<<z1<<"/"<<z2<<"="<<zd<<endl;
cout<<"Modulo= "<<z1<<"%"<<z2<<"="<<zmo<<endl;
}
Arithmetische Zuweisungsoperatoren
Die folgenden Anweisungsform ist üblich:

z.B. test= test + zahl; //Addiert zahl zu test
Kürzer ist die erlaubte Kombination aus Zuweisungsoperator und arithmetischen Operator,
welcher den sich wiederholenden Operanden wegfallen lässt.
z.B. test+= zahl; //Addiert zahl zu test
Es gibt für alle arithmetischen Operatoren einen entsprechenden arithmetischen

Zuweisungsoperator: +=, -=, *=, /= und %=.
z.B. test /= 3; //entspricht test = test /
Inkrementoperatoren
Der Operator ++ inkrementiert (addiert 1 dazu) sein Argument.
Präfix- und Postfixschreibweise hat eine Bedeutung, wenn es in einer Anweisung auftritt.
z.B. test= zahl1 * ++zahl2; //Präfix zahl2 wird vor de3r Multiplikation inkrementiert
test= zahl1 zahl2++; //Postfix zahl2 wird nach der Multipl. Inkrementiert
13
01.09.2003
oder
int zahl= 10
cout<< ++ zahl //Ausgabe 11
cout<< zahl ++ //Ausgabe 11
cout<< zahl //Ausgabe 12
Dekrementoperator
Der Operator – dekrementiert (subtrahiert 1) sein Argument.
Er kann ebenfalls in der Präfix- und Postfixschreibweise verwendet werden.
Zusammenfassung: Operatoren
Rang Operator Bedeutung, Verwendung

1 () Klammern bei Arithmetik, Funktionsaufrufe
2 - arithmetische Negation, d.h. negative Zahlen
! logische Negation
++ -- Inkrement und Dekrement
3 * / Multiplikation, Division
% Modulo bei Ganzahlen
4 + - Addition und Subtraktion
6 < <= Kleiner, kleiner gleich usw. bei Vergleichen
> >=
7 = = != Prüfung auf Gleichheit bzw. Ungleichheit
11 && logisches UND
12 || logisches ODER
14 = Zuweisungsoperator einschließlich aller verkürzten Formen
Was gibt folgendes Programm aus?
main()
{
int x;
int y;
int z ;
x = 100 ;
x /= 5 * 2 ;
x = 10 ;
x = 40 ;
x *= y = z = 2 ;
x = 80 ;
y= 2;
z= 2;
14
01.09.2003
x = 41 ;
x=y==2;
x=1;
y=2;
x = 42 ;
x==(y=4);
x = 42 ;
y=4;
Was gibt folgendes Programm aus?
main()
{
int x;
int y;
int z ;
x =10 ;
y =0 ;
z = -10 ;
x = x = = y || x ;
x=1
y = !y && z ;
y= 1;
z = 7 >= 6 >= 5 ;
z=0;
x = 10 ;
y=0;
z = -10 ;
!x && !y || z // Wert = 1
Welchen wert haben die Ausdrücke?
Int x = 2, y = 5, z = 7 ; float z1 = 1.3 ;
a.) ( x < 5 ) && ( z > y ) 1
b.) ( y <= x) || !( y < 4 ) 1
c.) ( x != 0 ) && ( z >= y ) 1
d.) y%5 – x -2
e.) z1 * x – y * z - 32,4
15
01.09.2003
Formatiert Ausgabe
( Hinweis : Bibliothek iomanip einbinden ! Gilt für neuere Compiler z.B. VC 6.0!)
Manipulatoren zur Formatierung von Ganzzahlen
Manipulator Wirkung
oct Oktale Darstellung
hex Hexadezimale Darstellung
dec Dezimale Darstellung (Standard)
showpos Positiven Zahlen werden mit Vorzeichen ausgegeben

noshopos Positiven Zahlen werden ohne Vorzeichen ausgegeben (Standard)
uppercase Hexadezimale Zahlen in Großbuchstaben
nouppercase Hexadezimale Zahlen in Kleinbuchstaben (Standard)
Manipulatoren zur Formatierung von Gleitpunkzahlen
Manipulator Wirkung
showpoint Der Dezimalpunkt wird stets angezeigt. Es werden so viele Ziffern
angezeigt, wie es der eingestellten Genauigkeit entspricht.
noshowpoint Abschließende Nullen hinter dem Dezimalpunkt werden nicht angezeigt.
Folgt dem Dezimalpunkt keine Ziffer, wird der Dezimalpunkt nicht
angezeigt. (Standard)
fixed Darstellung als Festpunktzahl
secientific Darstellung in exponentieller Notation

setprecision(n) Setzt die Genauigkeit auf n Stellen zur Anzeige (Standard: 6)
Hinweis:
fixed in Verbindung mit setprecision (n) Regelt die Nachkommastellen, wobei gerundet wird.
cout<<fixed<<setprecision(2)<<12.344 // Ausgabe: 12.34
16
01.09.2003
Aufgabe:
Erstellen Sie ein Projekt Formatierung in welchen Sie eine Ganze Zahl einlesen und die
Manipulatoren showpose und upperacase anwenden.
Programm:
#include <iomanip>
#include <iostream>
void main()
{
int zahl;
cout<<"Bitte geben Sie eine Ganzzahl ein! ";
cin>>zahl;
cout<<"Zahl 1="<<setw(5)<<showpos<<zahl<<endl;
cout<<"Zahl 2="<<setw(5)<<hex<<uppercase<<zahl<<endl;
}
Aufgabe:
Projekt Zinsen: Lesen Sie das Kapital den Zinssatz und die Laufzeit in Jahren ein. Berechnen
Sie anschließend die Zinsen. Hinweis: verwenden Sie fixed und setprecision zur
Formatierung.
#include <iostream>
#include <iomanip>
void main()
{
double Kapital,Zinssatz,Laufzeit,Zinsen;
cout<<"Berechnung von Zinsen"<<endl;

cout<<"Bitte geben Sie Ihr Kapital in EUR ein! ";
cin>>Kapital;
cout<<"Bitte geben Sie den Zinssatz in % ein! ";
cin>>Zinssatz;
cout<<"Bitte geben Sie die Laufzeit (1 Jahr) ein ";
cin>>Laufzeit;
//Berechnung
Zinsen=Kapital*(1+Zinssatz/100)-Kapital;
cout<<"Zinsen : "<<fixed<<setprecision(2)<<Zinsen<<" EURO"<<endl;
}
17
01.09.2003
Ergebnis: Zur Lösung mit mehreren Jahren benötigt man eine Funktion welche Potenzen
berechnen kann. Man benötigt die <cmath>.
Programm mit Funktionen

#include <iostream>
#include <iomanip>
#include <cmath>
void main()
{
double Kapital, Zinssatz, Laufzeit, Zinsen, Endkapital;
cout<<"Berechnung von Zinsen"<<endl;

cout<<"Bitte geben Sie Ihr Kapital in EUR ein! :";
cin>>Kapital;
cout<<"Bitte geben Sie den Zinssatz in % ein! :";
cin>>Zinssatz;
cout<<"Bitte geben Sie die Laufzeit in Jahren ein :";
cin>>Laufzeit;
//Berechnung
Endkapital=Kapital*pow((1+Zinssatz/100),Laufzeit);
Zinsen=Endkapital-Kapital;
cout<<"Endkapital : "<<fixed<<setprecision(2)<<Endkapital<<" EURO"<<endl;

cout<<"Zinsen : "<<fixed<<setprecision(2)<<Zinsen<<" EURO"<<endl;
}
Aufgabe:
Schreiben Sie ein Beispielprogramm in welchem Sie eine double Zahl einlesen und
anschließend die Manipulatoren zu Formatierung von Gleitpunktzahlen.
#include <iomanip>
#include <iostream>
#include <cmath>
void main()
{
double g;
cout<<"Bitte geben Sie ein Gleitpunktzahl ein! ";
18
01.09.2003
cin>>g;
cout<<"showpoint= "<<showpoint<<g<<endl;
cout<<"noshowpoint="<<noshowpoint<<g<<endl;
cout<<"fixed="<<fixed<<g<<endl;
cout<<"secientific= "<<scientific<<g<<endl;
cout<<"setprecision"<<setprecision(3)<<g<<endl;
}
Manipulatoren zur Feldausgabe

Manipulatoren Wirkung
setw(n) Setzt die Feldbreite auf n
setfill(ch) Setzt das Füllzeichen auf ch (Standard ist Leerzeichen)
left Linksbündige Ausgabe im Feld

right Rechtsbündige Ausgabe im Feld (Standart)
Internal Vorzeichen linksbündig, Wert rechtsbündig
Bsp:
#include <iostream>
#include <iomanip>
#include <cmath>

void main()
{
cout<<"Manipulatoren zur Feldausgabe"<<endl;
cout<<"Bitte ganze Zahlen eingeben : ";
int zahl; cin>>zahl;
cout<<"Ausgabe mit setw(20) und setfill('*') : "
<<setw(20)<<setfill('*')<<zahl<<endl;
cout<<"Ausgabe linksbuendig : "<<setw(20)<<left<<zahl<<endl;
cout<<"Ausgabe internal : "<<setw(20)<<internal
<<setfill(' ')<<showpos<<zahl<<endl;
}
19
01.09.2003
cmath wichtig Funktionen

Funktion Wirkung
abs(i) |i| Betrag ganzzahlig
fabs(x) |x| Betrag reell
ceil(x) Aufrunden
floor(x) Abrunden
pow(x,y) xy Exponentiation x, y reell
pow10(x) 10x Exponentiation x ganz
sqrt(x) Quadratwurzel x > =0
sin(x) Sinus im Bogen von 0 bis 2 Π
cos(x) Cosinus im Bogen von 0 bis 2Π
tan(x) Tangens im Bogen von 0 bis 2Π
exp(x) Exponentialfunktion ex
log(x) In x Logarithmus Basis e x >0
log10(x) log x Logarithmus Basis 10 x > 0
Typkonvertierung
a) in Ausdrücken:
Der Typ eines Ausdrucks richtet sich stets nach dem Operanten mit der höchsten
Genauigkeit, d.h. Operanten ganzzahlig Ausdruck ganzzahlig. Dies heißt implizite
Typumwandlung.
b) Ergebnisvariable:
Der Typ eines Ausdrucks wird implizit dem Typ der Ergebnisvariablen angepasst, d.h.
Ausdruck vom gleichen Typ der Ergebnisvariablen alles OK. Ausdruck vom höheren
Typ als Ergebnisvariable Problem da Stellen wegfallen können.
Ausdruck geringerer Typ als Ergebnisvariablen alles OK implizite Typumwandlung.
Man kann den Typ eines Operanten oder eines Ausdruckes auch explizit ändern mit Hilfe des
Cast- Operators ( )
Folge, Anweisung, Sequenz

Darstellung im Strucktogramm:
Eine einfache Anweisung wird im Strucktogramm durch ein Rechteck dargestellt.

Symbol:
Anweisung
Eine Folge von Anweisungen wird in einem Strucktogramm durch untereinanderliegende

Rechtecke dargestellt. Benutzerfreundlich wird eine Ausgabe auf dem Bildschirm durch ein
A: und anschließenden Text, und eine Eingabe durch ein E: mit anschließenden
Variablenbezeichner.
20
01.09.2003
z.B.
A: „ Bitte ganze Zahl eingeben.“
E: Zahl
Hinweis: Text sollte durch doppelte Anführungsstriche gekennzeichnet werden wegen

Unterschied zu Variablen.
Aufgabe 1:
Der Gesamtwiederstand zweier Parallel geschalten Widerstände soll nach Eingabe der beiden
Widerstandswerte berechnet werden.
Hinweis:
Rg=R1*R2/(R1+R2)
Erstellen Sie zuerst ein Strucktogramm mit Datenanalyse und schreiben Sie anschließend das
Programm.
Strucktogramm Parallele Widerstände:
A:" Widerstandsberechnung- Parallelschaltung"

A:" Bitte ersten Widerstandswert in Ohm eingeben!"
A:" Bitte zweiten Widerstandswert in Ohm eingeben!"
E:R1
E:R2
Rg =R1*R2/(R1+R2)
A: Rg
Datenanalyse:
Double: R1, R2, Rg

R1 : Widerstand 1
R2 : Widerstand 2
Rg : Gesamtwiderstand
21
01.09.2003
Programm:
#include <iomanip>
#include <iostream>
void main()
{
double R1,R2,Rg;
cout<<"Widerstandsberechnung-Parallelschaltung"<<endl;
cout<<"Bitte ersten Widerstand in Ohm eingeben : ";
cin>>R1;
cout<<"Bitte zweiten Widerstand in Ohm eingeben : ";
cin>>R2;
Rg=R1*R2/(R1+R2);
cout<<"Der Gesamtwidersand betraegt : "<<Rg<<"Ohm"<<endl;
}
Aufgabe 2:
Entwickeln Sie ein Strucktogramm und ein C++ Programm, welches für ein Rechtwinkliges
Dreieck bei Eingabe beliebiger Katheten a und b die Hypotenuse c und die Beiden Winkel
Alpha und Beta berechnet und ausgibt.
Hinweis:
c = √a²+b²
∠Bogen= arctan(b/a)
βBogen=arctan(a/b)
Der Arcustangens atan (Winkelbogen)
Konstante Π: M_PI
∠Grad/360=∠Bogen/2Π
22
01.09.2003
Struktogramm und Datenanalyse

Dreiecksberechnung
Datenanalyse: a,b,c,alpha,beta,PI=3.141592654
a: Seite a
b: Seite b
c: Seite c
alpha: Winkel Alpha
beta: Winkel Beta
A:"Dreiecksberechnung"
A:"Bitte gebe Sie Kathete a eingeben"
A:"Bitte gebe Sie Kathete b eingeben"
E:a
E:b
c2=(a*a)+(b*b);
c=sqrt(c2);
alpha=(180/Pi)*(atan(b/a));
beta=(180/Pi)*(atan(a/b));
A:"Alpha betraegt"
A:"Beta betraegt"
Programm:
#include <iostream>
#include <iomanip>
#include <cmath>
void main()
{
double a,b,c2,c,alpha,beta;
double Pi=3.141592654;
cout<<"Dreiecksberechnung"<<endl;
cout<<"Bitte geben Sie die Kathete a ein : ";
cin>>a;
cout<<"Bitte geben Sie die Kathete b ein : ";
cin>>b;
cout<<endl;
c2=(a*a)+(b*b);
c=sqrt(c2);
alpha=(180/Pi)*(atan(b/a));
23
01.09.2003
beta=(180/Pi)*(atan(a/b));
cout<<"Die Hypotenyse betraegt : "<<c<<"cm"<<endl<<endl;

cout<<"Alpha betraegt : "<<alpha<<" Grad"<<endl<<endl;
cout<<"Beta betraegt : "<<beta<<" Grad"<<endl<<endl;
}
Bedingte Programmausführung Auswahl, Selektion

In Abhängigkeit von einer Bedingung werden Anweisungen ausgeführt oder weggelassen
diese Bedingungen sind in der Regel an Vergleichsoperatoren geknüpft bzw. durch logische
Operatoren verbunden.
Einseitige Auswahl:
Bei der einseitigen Auswahl wird eine Anweisung oder eine Gruppe von Anweisungen nur
dann Ausgeführt wenn eine bestimmte Bedingung erfüllt ist.
Syntax:
If (Bedingung) {
Anweisung(en);
}
Struktogrammsymbol:
wahr Bedingung falsch
Anweisung(en)
Aufgabe:
Eine Firma liefert bei einem Bestellwert ab 200€ Porto und Verpackungsfrei. Für Aufträge
unter 200€ beträgt die Versandpauschale 3,50€. Ein Programm soll den Rechnungsbetrag in
Abhängigkeit vom Bestellwert ausgeben. Fertigen Sie ein Struktogramm mit Datenanalyse
und schreiben Sie anschließend das C++ Programm.

Bestellwert
Datenanalyse: b
b=Bestellwert
24
01.09.2003
A:“ Bestellwertsberechnung“
A:“ Bitte Bestellwert eingeben“
Bestellwert<200
Wahr Falsch
Anweisung
Programm:
#include <iomanip>
#include <iostream>
void main()
{
double b;
cout<<"Berechnung des Bestellwertes"<<endl<<endl;
cout<<"Bitte geben Sie den Bestellwert ein : ";
cin>>b;
if(b<200){
b+=3.50;
cout<<"Der Bestellwert betraegt : "<<b<<"EURO"<<endl;
}
Zweiseitige Auswahl
Bei der zweiseitigen Auswahl wir in der Abhängigkeit davon, ob eine Bedingung erfüllt ist
oder nicht jeweils eine bestimmte Anweisung oder Anweisungsgruppe ausgeführt.
Syntax:
If (Bedingung){
Anweisung(en)1;
25
01.09.2003
}
else{
Anweisung(en)2;
}
Struktogramm:
wahr Bedingung falsch
Anweisung(en)1Anweisung(en)2
Aufgabe:
Lesen Sie eine Natürliche Zahl ein und geben Sie anschließend aus ob die Zahl gerade oder
ungerade ist.(Struktogramm und Programm)
Struktogramm und Datenanalyse:

Gerade und ungerade Zahlen
Datenanalyse: n
n= natürliche Zahl
A:“Bitte geben Sie eine natürliche Zahl ein „
E:n
n % 2 = =0
Wahr Falsch
A:“Zahl ist gerade“ A:“Zahl ist

ungerade“
26
01.09.2003
Programm:
#include <iomanip>
#include <iostream>
void main()
{
int n;
cout<<"Bitte geben Sie eine natürliche Zahl ein : ";
cin>>n;
if(n%2==0){
cout<<endl;
cout<<"Ihre Zahl ist gerade"<<endl;
}
else{
cout<<endl;
cout<<"Ihre Zahl ist ungerade"<<endl;
}
}
Aufgabe :
Lesen Sie die Koordinaten x, y eines Punktes P ein und Treffen Sie anschließend eine
Aussage über die Lage des Punktes in einem Koordinatensystems.
Lade eines Punktes im Koordinatensystem
Datenanalyse:
double x, y
x = x- Koordinate
y = y- Koordinate
27
01.09.2003
A:Lage eines Punktes im Koordinatensystems
A:Bitte x- Koordinate eingeben
E:x
A:Bitte y-Koordinate eingeben
E:y
x>0 && y> 0
Wahr Falsch
A:Punkt im 1.Quadrant
x<0 && y> 0
Wahr Falsch
A: Punkt im 2. Quadrant
x<0 && y< 0
Wahr Falsch
x>0 && y< 0
Wahr Falsch
x= =0 && y= = 0
Wahr Falsch
Punkt im Koordinatenursprung
x= 0 && y!= 0
Wahr Falsch
Punkt auf y- Achse
x<0 && y> 0

Wahr Falsch
A: Punkt auf x - Achse
28
01.09.2003
Programm:
#include <iomanip>
#include <iostream>
void main()
{
double x,y;
cout<<"Bestimmung der Koordinaten "<<endl;
cout<<"Bitte die x Koordinate eingeben : ";
cin>>x;
cout<<"Bitte die y Koordinate eingeben : ";
cin>>y;
if(x>0 && y>0){

cout<<"Der Punkt liegt im 1. Quadranten!"<<endl;
}
if(x<0 && y>0){

}
if(x<0 && y<0){

}
if(x>0 && y<0){

}
if(x==0 && y==0){

cout<<"Der Punkt ist im Koordinatenursprung"<<endl;
}
if(x==0 && y!=0){

cout<<"Der Punkt ist auf der y-Achse"<<endl;
}
if(y==0 && x!=0){

cout<<"Der Punkt ist auf der x-Achse"<<endl;
}
}
29
01.09.2003
Aufgabe:
Lesen Sie die Seiten eines Dreieckes ein. Stellen Sie anschließend fest ob das Dreieck
existiert. Wenn das Dreieck existiert stellen Sie fest ob es ein Gleichseitiges,
Gleichschenkliges oder Ungleichseitiges ist.
Hinweis: Ein Dreieck existiert wenn die Summe 2er Seiten stets größer ist als die 3. Seite
(Dreiecksungleichung)

Dreiecksberechnung
Datenanalyse:
Double a,b,c;
a = Seite a
b = Seite b
c = Seite c
A: Dreiecksberechnung
A: Bitte Seite a eingeben
E: a
A: Bitte Seite b eingeben
E: b
A: Bitte Seite c eingeben

E:c
a+b>c && a+c>b && c+b>a

Wahr Falsch
A:Dreieck existiert A: Dreieck
Existiert nicht
a==b || a==c || c==b
Wahr Falsch
A: Dreieck ist Gleichschenklig
a==b && b==c

Wahr Falsch
A: Dreieck ist gleichseitig
a!=b && b!=c

Wahr Falsch
A: Dreieck ist Ungleichseitig
30
01.09.2003
Programm:
#include <iomanip>
#include <iostream>
void main()
{
double a,b,c;
cout<<"Dreiecksberechnung"<<endl;
cout<<"Bitte die Seite a eingeben! : ";
cin>>a;
cout<<"Bitte die Seite b eingeben! : ";
cin>>b;
cout<<"Bitte die Seite c eingeben! : ";
cin>>c;
if(a+b>c && a+c>b && c+b>a){

cout<<"Das Dreieck existiert"<<endl;
}
if(a==b || a==c || c==b){

cout<<"Das Dreieck ist Gleichschenklig"<<endl;
}
if(a==b && b==c){

cout<<"Das Dreicek ist Gleichseitig"<<endl;
}
if(a!=b && b!=c){

cout<<"Das Dreieck ist Ungleichseitig"<<endl;
}
}
else{
cout<<"Das Dreieck existiert nicht"<<endl;
}
}
Aufgabe:
BMI
Im Tafelwerk Seite 141 finden Sie ein Übersicht zur Berechnung des BMI. Entwickeln Sie ein
Struktogramm und ein C++ Programm welches nach Eingabe des Gewichtes und der
Körpergröße einer Person den entsprechenden Zustand der Person auf dem Bildschirm
ausgibt.
31
01.09.2003
Struktogramm und Datenanalyse:

BMI
Datenanalyse:
Double bmi, kg, kgw;

bmi= Body Mass Index
kg= Körpergewicht
kgw= Körpergröße
A: Berechnung des BMI
A: Bitte Koerpergoesse in m eingeben
E: kg
A: Bitte Koerpergewicht in kg eingeben
E: kgw
bmi=kgw/(kg*kg)
A: Der BMI wert betraegt
bmi<20
Wahr Falsch
A: Sie haben Untergewicht
bmi>=20 && bmi<25

Wahr Falsch
A: Sie haben Normalgewicht
bmi>=25 && bmi<30

Wahr Falsch
A: Sie haben Übergewicht
bmi>=30 && bmi<40

Wahr Falsch
A: Sie haben Fettsucht
bmi>=40
Wahr Falsch
A: Sie haben Massive Fettsucht
32
01.09.2003
Programm:
#include <iomanip>
#include <iostream>
void main()
{
double bmi,kg,kgw;
cout<<setw(120)<<"Berechnung des BMI"<<endl<<endl;
cout<<"Bitte Koerpergoesse in m eingeben : ";
cin>>kg;
cout<<"Bitte Koerpergewicht in kg eingeben : ";
cin>>kgw;
cout<<endl;
bmi=kgw/(kg*kg);
cout<<"Der BMI wert betraegt"<<bmi<<endl<<endl;
if(bmi<20){
cout<<"Sie haben Untergewicht"<<endl<<endl;
}
if(bmi>=20 && bmi<25){
cout<<"Sie haben Normalgewicht"<<endl<<endl;
}
if(bmi>=25 && bmi<30){
cout<<"Sie haben Übergewicht"<<endl<<endl;
}
if(bmi>=30 && bmi<40){
cout<<"Sie haben Fettsucht"<<endl<<endl;
}
if(bmi>=40){
cout<<"Sie haben Massive Fettsucht"<<endl<<endl;
}
}
33
01.09.2003
Mehrseitige Auswahl
Es gibt 2 Formen der Mehrseitigen Auswahl, die sich darin unterscheiden wie man sie
programmieren kann. Die erste Art ist sehr speziell und beruht darauf das die einzelnen Fälle
sich durch feste Einzelwerte bestimmen lassen.
Syntax:
Switch (Auswahlvariable) {
case Konst 1: Anweisung; break;
case Konst n: Anweisung; break;
default : Anweisung;
}
Abarbeitung:
Der Wert der ganzzahligen Auswahlvariablen wird fortlaufend mit den Werten der
Konstanten nach dem case verglichen. Kommt es zu einer Übereinstimmung werden die
Anweisungen des entsprechenden case Zweiges bis zum break ausgeführt. Gab es keine
Übereinstimmung werden die Anweisungen des default Zweiges ausgeführt (dieser ist
optional).
Hinweis:
Steht kein break in den case Zweigen werden nach einer Übereinstimmung alle
nachfolgenden Anweisungen ohne weitere Prüfung ausgeführt.
Struktogramm
Auswahlvariable
Konst1 Konst2 Konst3 Konst4 Konst n default
Anweisung Anweisung Anweisung Anweisung Anweisung
Anweisung
break break break break break
Anwendung:
Verwendet wird die switch- Anweisung vorwiegend zum Aufbau von Menüs.
34
01.09.2003
Aufbau eines Menüs:

#include <iostream>
#include <conio.h> //für getch() notwendig
#include <iomanip>
void main()
{
//1. Schritt Ausgabe des Menuetextes
cout<<endl<<"Berechnung von Flaecheninhalten"<<endl;
cout<<"1 Quadrat "<<endl;
cout<<"2 Kreis "<<endl;
cout<<"3 Rechteck "<<endl;
cout<<"Ihre Wahl? "<<endl;
//2. Einlesen der Wahl
char wahl=getch(); //mit echo getche()
//auch mit cin möglich
//3. Auswertung der Variablen
switch (wahl){
case'1': cout<<endl<<"Berechnung zum Quadrat "<<endl;
cout<<"Bitte die Seite des Quadrates eingeben : "<<endl;
double a; cin>> a;
cout<<"Der Flaecheninhalt des Quadrates betraegt: "<<a*a<<endl;
break;
case'2': cout<<endl<<"Berechnung zum Kreis "<<endl;
//weiter siehe Quadrat
break;
case'3': cout<<endl<<"Berechnung zum Rechteck "<<endl;
//weiter siehe Quadrat
break;
default: cout<<endl<<"Falsche Auswahl!! "<<endl;
}
}
Vervollständigen sie das obere Programm!
#include <iostream>
#include <iomanip>
void main()
{
35
01.09.2003
//1. Schritt Ausgabe des Menuetextes

double PI= 3.141592654;
//2. Einlesen der Wahl
char wahl=getch(); //mit echo getche()
//3. Auswertung der Variablen

switch (wahl){
double a; cin>> a;
break;
double A,r;
cout<<"Bitte Radius eingeben ";

cin>>r;
A=PI*r*r;
cout<<"Der Flaecheninhalt betraegt"<<A<<endl;
break;
cout<<"Bitte geben sie eine Seite ein! "<<endl;
double b;
cin>>b;
A=b*b;
cout<<"Der Flaecheninhalt betraegt "<<A<<endl;
break;
}
}
36
01.09.2003
Aufgabe:
Ergänzen Sie das Programm um ein Obermenü welches als Menüpunkte
1.Berechnung Flächen
2. Berechnung von Körpern
Und ein zugehöriges Untermenü welches die Berechnung des Volumens von drei Körpern
anbietet.
Hinweis: Löschen des Bildschirms mit der Anweisung system(„cls“);

// cstdlib einbinden
Programm:
#include <iostream>
#include <iomanip>
#include <cstdlib>
void main()
{
double PI= 3.141592654;
char wahl;
cout<<setw(135)<<"Berechnung von Flaecheninhalt und Volumen"<<endl<<endl;
cout<<"1 Flaechen"<<endl;
cout<<"2 Koerper "<<endl;
wahl=getch();
switch (wahl){
case'1':
char wahl2;
system("cls");
wahl2=getch();
switch (wahl2){

double a; cin>> a;
break;

double A,r;
cout<<"Bitte Radius eingeben ";

cin>>r;
A=PI*r*r;
37
01.09.2003
cout<<"Der Flaecheninhalt betraegt"<<A<<endl;

break;

cout<<"Bitte geben sie eine Seite ein! : ";
double b,A1;
cin>>b;
A1=b*b;
cout<<"Der Flaecheninhalt betraegt "<<A1<<endl;
break;
}
break;
case'2':
system("cls");
cout<<endl<<"Berechnung des Volumens"<<endl;
cout<<"1 Würfel "<<endl;
cout<<"2 Quader "<<endl;
cout<<"3 Kugel "<<endl;
char wahl3=getch();
switch (wahl3){
case'1': double y;
cout<<"Berechnung zum Würfel "<<endl;
cout<<"Bitte eine Seite eingeben! : ";
cin>>y;
cout<<"Das Volumen betraegt : "<<y*y*y<<"cm3"<<endl;
break;
case'2': double x,d,c;

cout<<"Berechnung zum Quader "<<endl;
cout<<"Bitte Seite a eingeben : ";
cin>>x;
cout<<"Bitte Seite b eingeben : ";
cin>>d;
cout<<"Bitte Seit c eingeben :";
cin>>c;
cout<<"Das Volumen betraegt : "<<x*d*c<<"cm3"<<endl;

break;
case'3': double h;
cout<<"Berechnung zur Kugel "<<endl;

cout<<"Bitte Raius eingeben : ";
cin>>h;
cout<<"Das Volumen betraegt : "<<(4/3)*PI*h*h*h<<" cm3"<<endl;
break;
default: cout<<"Falsche Taste"<<endl;
}
}
}
38
01.09.2003
Mehrseitige Auswahl mit verschachtelten if- else Anweisungen

Falls die Auswahlvariable kein abzählbarer Datentyp ist oder die Bedingung für die Einzelnen
Fälle komplizierter sind muss auf eine verschachtelte Zweiseitige Auswahl oder auf mehrere
If- Anweisungen zurückgegriffen werden.
Aufgabe:
Einzugeben ist die erreicht Punktzahl und die Gesamtpunktzahl. Die entsprechende
Prozentzahl ist zu ermitteln und die zugehörige Note ist auszugeben.
Note 1- 95%
2- 80%
3- 65%
4- 50%
5- 30%
6- schlechter
Programm:
#include <iostream>
#include <iomanip>
void main()
{
double x,p,gp;
cout<<setw(135)<<"Berechnung der Note "<<endl<<endl<<endl;
cout<<"Bitte Ihre Punktzahl eingeben : ";
cin>>p;
cout<<"Bitte die zu erreichenden Punkt eingeben : ";
cin>>gp;
x=(p/gp)*100;
if(x>=95){
cout<<"Sie haben die Note 1 "<<endl;
}
if(x<95 && x>=80 ){

}
if(x<80 && x>=65 ){
}
if(x<65 && x>=50 ){

}
39
01.09.2003
if(x<50 && x>=30 ){

}
if(x<30){
}
Phasen der Programmentwicklung

1. Problemanalyse – Aufgabenstellung
2. Festlegung der Datenstrukturen und Algorithmen
3. Quellcodes, Übersetzung und Fehlerkorrektur
4. Programmtest (Vergleich von Testdaten des Programms)
5. Programmdokumentation
Schleifen
In Abhängigkeit einer Bedingung oder Laufbedingung werden Anweisungen wieder holt
dabei unterscheidet man ob die Bedingung am Schleifenanfang oder Schleifenende geprüft
werden.
Schleife mit End- Abfrage:

Die Schleife mit End- Abfrage wird mindestens einmal durchlaufen. Sie wird auch
Fußgesteuerte Schleife benannt. Die Schleife wird solange wiederholt wie die Laufbedingung
war ist.
Syntax:
do{
Anweisung;
// Schleifenkörper
}while (<Laufbedingung>);
Struktogramm:
Anweisung welche bei jedem Durchlauf wiederholt werden
Laufbedingung
40
01.09.2003
Anwendung:
1. zur Programmwiederholung
char ant; //Variabe außerhalb der Schleife

do{
Programm welches
wiederholt werden
soll
cout<<“ Programm wdh j/n“;

ant= getch( );
}while (ant != ‘n’);
2.Anwendung der Do- While Schleife

Überprüfung von Eingaben:
z.B. ‚j’ oder ‚n’
Syntax:
do {
ant = getch( ); // Einlesen der Taste
if(ant!= ‚j’ && ant!= ‚n’)
cout<<(char)7<<(char)7 ;
}while (ant != ‚j’ && ant != ‘n’);
Anwendung zur do{}while- Schleife (Schleife mit Endabfrage)
A: Soll das Programm wiederholt werden j/n?
E: antw (getch)
antw != ‚j’ && antw != ‚n’

Wahr Falsch
A: (char)7
antw != ‚j’ && antw != ‚n’
41
01.09.2003
Aufgabe:
Schreiben Sie ein Programm in welchem der Benutzer Aufgefordert wird eine Natürliche Zahl
im Intervall 1- 100 einzugeben.
Führen Sie eine Eingabeüberprüfung durch!. Zeichnen Sie zuerst das Strucktogramm.
Bildschirm löschen
A: Bitte geben Sie eine natürliche Zahl zwischen 1 und 100 ein!!
E: zahl
zahl< 1|| zahl> 100
Wahr Falsch
A: Beep Beep
zahl<1 || zahl> 100
Programm:
#include <iostream>
#include <iomanip>
#include <conio.h>
void main()
{
int zahl;
do{
system("cls");
cout<<"Bitte geben Sie eine natürliche Zahl zwischen 1 und 100 ein!! ";
cin>>zahl;
if(zahl<1 || zahl>100){
cout<<(char)7;
}
}while(zahl <1 || zahl >100);
}
42
01.09.2003
Vorgehensweise zum nutzen der Bibliothek console.h

1. Schritt: Dateien console.h und console.cpp dem Projekt hinzufügen
2. Schritt: #include „console.h“ einbinden
3. Schritt: Speichern der Dateien im Ordner des Arbeitsbereiches mit Speichern unter
4. Schritt: Hinweis: cls( ) zum Bildschirm löschen, setCursor zum Positionieren des
Cursors, setColor zum setzen der Zeichenfarbe (0-15 Zeichenfarbe+ von 16-
255 Hintergrundfarbe jeweils in 16 Schritten), cursorOff (Schaltet Cursor
aus), cursorOn (Schaltet Cursor an)
Schleife mit Anfangsabfrage While- Schleife

Bei der While- Schleife kann es vorkommen das der Schleifenkörper nie durchlaufen wird,
weil die Schleifenbedingung schon zu Anfang nicht zutrifft. Solange die Bedingung nach dem
While wahr ist wird der Schleifenkörper wiederholt.
Syntax:
While (Bedungung) {
Anweisung;
}
Struktogramm:
Bedingung
Anweisung
A.................
Anwendung:
Die while- Schleife wird verwendet wenn die Anzahl der Wiederholungen unbekannt ist. Und
wenn es erforderlich sein kann die Schleife gar nicht zu durchlaufen.
Aufgabe:
Der Benutzer möchte Messwerte in unbekannte Anzahl eingeben. Ein Abbruch der Eingabe
erfolg wenn der Messwert dem Wert null erhält. Berechnen Sie anschließend den
Durchschnitt der Messwerte. Erstellen sie ein Struktogramm.
43
01.09.2003
Datenanalyse:
Double Wert ,d;
float anz=0 ,sum;
Wert= Wert der Eingabe des Benutzers
d = Durchschnitt
anz = Anzahl der eingegebenen Werte
sum= Summe der eingegebenen Werte
A: Berechnung des Wertedurchschnitts zum Beenden Null druecken
sum= 0
anz= 0
A: Bitte Wert eingeben
E: Wert
Wert! =0
anz++
sum= sum+ Wert
A: Bitte Die Werte eingeben
E: Wert
anz = =0
Wahr Falsch
A: Kein gueltigen Messwerte d=sum/anz
A: „Der Durchschnitt betraegt“
Programm:
#include <iostream>
#include <iomanip>

double Wert;
void main()
{
double d;
44
01.09.2003
float anz=0,sum=0;
cout<<setw(40)<<"Berchnung des Wertedurchschnittes" <<endl<<endl;
cout<<"Bitte Wert eingeben :";
cin>>Wert;
while (Wert!=0){
cout<<"Bitte Wert eingeben :";
cin>>Wert;
anz ++;
sum=sum+Wert;
if(anz==0){
cout<<"Bitte Wert eingeben : ";
cin>>Wert;
}
}
if(anz==0){
cout<<"Kein gueltigen Messwerte"<<endl;
}
else{
cout<<"Der Durchschnitt betraegt "<<sum/anz<<endl;
}
}
Zähl-Schleife (for- Schleife)

Die Zähl-Schleife ist eine Strucktur bei der von Anfang an fest steht wie viele
Wiederholungen ausgeführt werden. Dabei wird ein Zähler (Laufvariable) mitgeführt.
Syntax:
for( Laufvariable = Anfangswert; Laufvariable= = Endwert; Laufvariable++){
Anweisung;
}
Die Laufvariable erhält nur einmal zu beginn der Schleife den Anfangswert.
Die Laufbedingung Laufvariable <= Endwert wird ausgewertet, ist Sie war wir der
Schleifenkörper ausgeführt. Anschließend wird die Laufvariable hochgezählt.
Dann wider Test der Laufbedingung usw.
Bsp: //Ausgabe 20 Sterne;

for (int i=1; i<20; i++){
cout<<”*”;
}
45
01.09.2003
Struktogramm:
Für Laufvariable von Anfangswert bis Endwert
Anweisung
Für i von 1 bis 20
A: „*“
Aufgabe:
Geben Sie auf dem Bildschirm mit Hilfe einer for – Schleife die natürlichen Zahlen von 1- 10
mit ihrem Quadrat und Kubik zahlen aus.
Anwendung der for- Schleife:

1. Summe von Natürlichen Zahlen bilden.
Aufgabe:
Lesen Sie eine natürliche Zahl ein summieren Sie alle natürlichen Zahlen einschließlich dieser
Zahl und geben Sie das Ergebnis aus.
Programm:
#include <iomanip>
#include <iostream>
46
01.09.2003
void main()
{
int Zahl;
cout<<"Bitte nat. Zahl eingeben!!!! ";
cin>>Zahl;
int summe=0;
for(long i=1; i<Zahl;i++){
summe=summe+i;
}
cout<<"Summe : "<<summe<<endl;
}
Fakultät einer nat. Zahl

Aufgabe:
Eine nat. Zahl ist einzulesen und die Fakultät zu berechnen und anschließend auf dem
Bildschirm auszugeben. (Produkt von 1 und allen Nachfolgern dieser Zahl)
Programm
#include <iomanip>
#include <iostream>
void main()
{
int Zahl;
cout<<"Bitte nat. Zahl eingeben!!!! ";
cin>>Zahl;
int fakt=1;
for(long i=2; i<Zahl;i++){
fakt=fakt*i;
}
cout<<"Fakultät beträgt : "<<fakt<<endl;
}
Teiler einer nat. Zahl

Lesen Sie eine nat. Zahl ein und geben Sie anschließend alle echten Teiler dieser Zahl aus.
Programm:
#include <iostream>
47
01.09.2003
#include <iomanip>
void main()
{
int zahl;
cout<<"Bitte geben Sie eine nat. Zahl ein";

cin>>zahl;
for(long teiler=2; teiler < zahl;teiler++){

if(zahl % teiler==0){
cout<<" "<<teiler;
}
}
cout<<endl;
}
Priemzahl
Aufgabe:
Eine nat. Zahl ist einzulesen und anschließend festzustellen ob diese Zahl eine Priemzahl ist.
#include <iomanip>
#include <iostream>
void main()
{
long zahl;
cout<<"Bitte geben sie eine nat. Zahl";

cin>>zahl;
int primtest=1;
for (long teiler =2; teiler <zahl ;teiler ++){
if(zahl% teiler ==0){
primtest= 0 ;
}
if(primtest && zahl>1){
cout<<zahl<<" ist eine Primzahl !"<<endl;
}
else{
cout<<zahl<<" ist keine Primzahl !"<<endl;
}
48
01.09.2003
5. Potenz
Aufgabe
Lesen Sie die Basis und die ganzzahligen Exponenten einer Potenz ein (Exponent>=0) und
berechnen Sie anschließend die Potenz.
z.B. 34= 3*3*3*3=81
Lösen Sie die Aufgabe mit Hilfe der for- Schleife. Verwenden Sie nicht Pow.
Programm:
#include <iomanip>
#include <iostream>
void main()
{
double basis;
cout<<"Bitte basis eingeben : ";
cin>>basis;
long exponent;
cout<<"Bitte geben Sie die den Exponenten ein : ";
cin>>exponent;
double potenz=1;
for (long i=1;i<= exponent; i++){

potenz*=basis;
}
cout<<basis<<" hoch "<<exponent<<" : "<<potenz<<endl;
}
For- Schleife mit variabler Schrittweite

Ersetzt man die Inkrementierung der Laufvariablen (Laufvariable++ ) durch einen anderen
Inkrementausdruck (Laufvariable +=5) dann ergibt sich eine for- Schleife mit variabler
Schrittweite.
Aufgabe:
Geben Sie eine Wertetabelle für die Funktion f(x)=x²-2 im Intervall von –3 bis +3 aus. Eine
geeignete Schrittweite ist vom Benutzer einzugeben.
49
01.09.2003
Programm:
#include <iomanip>
#include <iostream>
void main()
{
double xl,xr;
cout<<"Bitte die linke und die rechte Intervalallgrenze eingeb "<<endl;
cin>>xl>>xr;
double schritt;
cout<<"Bitte geben Sie die Schrittweite ein : ";
cin>>schritt;
cout<<setw(10)<<" x "<<setw(25)<<"f(x)=x*x-2"<<endl;
for( double x=xl; x<= xr; x+=schritt){
cout<<setw(10)<<fixed<<setprecision(2)<<x;
cout<<setw(20)<<fixed<<setprecision(2)<<x*x-2;
cout<<endl;
}
}
Verschachtelte Schleifen
Von Verschachtelten Schleifen spricht man wenn sich im Körper einer Schleife (äußere
Schleife) eine weitere Schleife (innere Schleife befindet). Bei jedem Durchlauf der äußeren
schleife wird die innere Schleife vollständig abgearbeitet.
Aufgabe:
Geben Sie ein Multiplikationstabelle für das kleine 1*1 von 1-10 aus.
Programm:
#include <iomanip>
#include <iostream>
void main()
{
cout<<"Multiplikarionstabelle für das kleine 1*1 von 1-10 "<<endl<<endl;
for(int i=1;i<=10;i++){
cout<<setw(4)<<i;
for(int j=1;j<=10;j++){
50
01.09.2003
cout<<setw(4)<<i*j;
}
cout<<endl;
}
}
Aufgabe Primzahlen:
Lesen Sie eine nat. Zahl ein und geben Sie anschließend alle Primzahlen aus die kleiner gleich
dieser zahl sind.
Programm:
#include <iomanip>
#include <iostream>
void main()
{
long n;
cout<<"Bitte geben sie eine nat. Zahl : ";

cin>>n;
for(int zahl=2;zahl<n ;zahl++){
int primtest=1;
for (long teiler =2; teiler <n ;teiler ++){
if(n% teiler ==0){
primtest= 0 ;
}
if(primtest && n>1){
cout<<zahl<<" ist eine Primzahl !"<<endl;
}
else{
cout<<zahl<<" ist keine Primzahl !"<<endl;
}
}
}
51
01.09.2003
Andere Steueranweisung für Schleifen

Die Anweisung break
Die break- Anweisung bewirkt einen Ausstieg aus einer Schleife, analog wie bei einer
switch- Anweisung. Der Ausstieg erfolgt aber nur aus der Konstruktion heraus, in der das
break eingebettet ist.
z.B.
/Primzahlen von 1-100

int test=1;
for (int zahl= 2; zahl <= 100; zahl ++){
for (int teiler= 2; teiler <zahl; teiler++){
if( zahl % teiler = = 0 ){ //Test auf Primzahl
test= 0; //keine Primzahl
break;
}
}
if( test ){
cout<<setw(4)<<zahl;
}
test= 1;
}
Die Anweisung continue

Die continue- Anweisung kehrt zum Anfang der Schleife zurück und ignoriert den Rest des
Schleifenkörpers.
z.B.
//Einlesen einer Zahl im Bereich 1-100

do{
cout<<“ Bitte Zahl im Bereich von 1-100 eingeben“;
cin>>zahl;
if(zahl < 1|| zahl> 100 ){
cout<< “ \nZahl ist nicht Bereich von 1-100!“;
continue;
}
}while(0);
Die goto- Anweisung

Das Schlüsselwort goto gefolgt von einer Sprungmarke, bewirkt, dass das Programm zu
dieser Sprungmarke verzweigt.
z.B.
goto Sprungmarke;
//Anweisung (en)
52
01.09.2003
Sprungmarke; //der Sprungmarke muß ein Doppelpunkt folgen

//hier wird das Programm fortgesetzt
Aufgabe:
Der Erfinder des Schachspiels Sessa hatte einen Wunsch frei. Er erbat sich die Summe der
Weizenkörner die sich ergibt wenn für das erste Feld 1 Korn für das 2. Feld 2 Körner für das
3. Feld 3 Körner usw.
Schreiben Sie ein Programm das für 64 Felder die Gesamtzahl der Körner berechnet. Geben
Sie das Gewicht der Körner an, wenn 200 Körner 1g wiegen. Wie viele Eisenbahnwagons
bräuchte man für Transport des Weizens und wie lange währe der Zug wenn in einen
Eisenbahnwagon 30t passt und 15 Meter lang ist.
Programm:
#include <iomanip>
#include <iostream>
void main()
{
cout<<fixed<<setprecision(0);
double Anzahl=1;
double Waggonzahl, Gewicht,Laenge;
for(long i=1;i<65;i++){
Anzahl*=2;
}
cout<<" Anzahl der Koerner "<<Anzahl<<" stueck "<<endl;
Gewicht=(Anzahl/200)/1000000;
cout<<" Gewicht der Koerner "<<Gewicht<<" t "<<endl;
Waggonzahl=Gewicht/30;
cout<<" Waggonanzahl "<<Waggonzahl<<endl;
Laenge=(Waggonzahl*15)/1000;
cout<<" Laenge des Zuges "<<Laenge<<endl;
Pytagoräische Triepel
Sind nat. Zahlen welche die Gleichung c²=a²+b² erfüllen.

Suchen Sie alle Pytagoräische Triepel abc<= 1000.
Hinweis: verschachtelte schleifen entfernen
Programm:
#include <iomanip>
#include <iostream>
53
01.09.2003
void main()
{
long a,b,c;
for(a=1;a<=100 ; a++){
for(int b=1; b<=100; b++){
for(int c=1;1<=100;c++){
if(a*a+b*b==c*c)&&(a<b)){
cout<<"a : "<<setw(3)<<a
<<"b : "<<setw(3)<<b
<<"c : "<<setw(3)<<c
<<endl;
}
}
}
}
}
Funktionen bzw. Unterprogramme

Eine Funktion gruppiert eine Reihe von Anweisungen zu einer Einheit und gibt ihr einen
Namen.
Vorteile:
• Programme werden übersichtlicher
• Probleme können in kleine Teilprobleme zerlegt werden
• Gruppen- arbeit ist möglich
• Funktionen können ständig wiederverarbeitet werden
• Fehler lassen sich leichter finden
Einfache- Funktionen
Werden ohne Parameter aufgerufen und geben keinen Wert zurück.
Es ist in C++ gebräuchlich die Funktion am Anfang des Programms zu deklarieren bzw. den
Prototyp der Funktion anzugeben. Hier wird dem Compiler mitgeteilt, dass eine Funktion mit
diesem Namen geplant ist.
Syntax der Deklaration:

void <Namen der Funktion>( ); //Prototyp der Funktion
Definition der Funktion

Die Definition der Funktion erfolgt in der Regel nach der Hauptfunktion main()
54
01.09.2003
Syntax der Definition:

void <Namen der Funktion>( );
{
Anweisung(en);
}
Syntax des Aufrufes einer Funktion:

<Namen der Funktion>( );
Beispiel: #include …
void sternlinie(); //Deklaration der Funktion
void main()
{
sternlinie(); //Aufruf der Funktion

}
void sternlinie()
{
for(int i=0; i<45; i++){

cout<<“*“;
}
cout<<endl;
}
Aufgabe
Durchschnittsverbrauch:
Gefahrene Kilometer und der Verbrauch in Liter in einer Funktion Eingabe für PKW
einzulesen. In einer Funktion Verarbeitung ist der Durchschnittsverbrauch je 100 Kilometer
zu berechnen. In einer Funktion Ausgabe ist das Ergebnis auszugeben und einen eine
entsprechende Aussage über den Verbrauch zu treffen z.B. bis 8 Liter Verbrauch in Ordnung,
8-10 Liter Verbrauch geht noch, ab 10 Liter Geld kann sinnvoller ausgegeben werden.
Programm:
#include <iostream>
#include <iomanip>
void eingabe();
void verarbeitung();
void ausgabe();
int l, km, ges;
void main()
55
01.09.2003
{
eingabe();
verarbeitung();
ausgabe();
}
void eingabe()
{
cout<<"Bitte geben sie die gefahrenen km ein: ";

cin>>km;
cout<<"Und die verbrauchten Liter: ";
cin>>l;
}
void verarbeitung()
{
ges=(100*l)/km;
}
void ausgabe()
{
cout<<"Der Verbrauch auf 100km ist: "<<ges<<" l"<<endl<<endl;
if(l<8){
cout<<"Billigwagen!!!"<<endl;
}
if(l>=8 &&l<10){
cout<<"Mittelklasse wagen!!!"<<endl;
}
if(l>10){
cout<<"Scheisskarre aber ordentlich PS!!!"<<endl;
}
globale Variablen
Globale Variable werden außerhalb jeder Funktion des Programms deklariert. Sie sind
dadurch in allen Funktionen des Programms bekannt und verwendbar.
Deshalb sollten Sie ihre Variablen sehr sparsam verwendet werden.
Lokale Variablen
Lokale Variable in C++ sind nur in den Sie einschließenden geschweiften Klammern
(Programmblock) bekannt und veränderbar.
Sichtbarkeit von globalen und lokalen Variablen

Haben eine globale und lokale Variable den gleichen Bezeichner so überdeckt die lokale
Variable die globale. Möchte man die globale Variable trotzdem sichtbar machen so stellt
man hier einen doppelten Doppelpunkt voran.
56
01.09.2003
Funktion mit Wertparameter

Bei Funktionen mit Wertparameter hat man die Möglichkeit der Funktion beim Aufruf Werte
zu übergeben. Diese Werte werden vom Typ in der Parameterliste angegeben.
Syntax
Void Fkt (Parameterliste)
Die Parameterliste besteht aus Datentypen welche durch Komma getrennt werden und die Art
(Typ) und die Reinfolge der Parameter festlegt.
Beispiel:
void wdhzeichen(char, int); //Deklaration der Funktion
void main()
wdhzeichen(’-’,45); //Aufruf der Funktion mit Konstanten Werten
}
void wdhzeichen(char ch, int n) //Definition der Funktion
{
for(int i=0; i!=n; i++){
cout<<ch;
}
}
Aufruf der Funktion
Der Aufruf der Funktion erfolg über den Namen und den in runden stehenden aktuellen
Parametern, welche im Typ und Anzahl mit der Parameterliste übereinstimmen müssen.
Aktuelle Parameter können sein Konstanten, Variablen, Ausdrücke usw.
Zusatz:
Der Prototyp teilt dem Compiler den Namen der Funktion die Typen und die Anzahl der
Parameter sowie den Typ des Rückgabewertes mit.
Definition der Funktion:
Weist den Parametern Bezeichner zu unter welchen sie in der Funktion als lokale Variablen
benutzt werden können.
Hinweis:
Bei der Verwendung von Variablen muss der Programmierer genaue Kenntnisse über den
Gültigkeitsbereich und Sichtbarkeit besitzen.
57
01.09.2003
Beispiel:
#include <iomanip>
#include <iostream>
void wdhzeichen(char, int);
void main()
{
char h; int z;
cout<<"Bitte Zeichen eingeben : ";
cin>>h;
cout<<"wie oft : ";
cin>>z;
wdhzeichen(h,z);
}
void wdhzeichen(char ch, int n)
{
for(int i=0; i<n; i++){
cout<<ch;
}
}
Darstellung im Strucktogramm:
Aufruf der Funktion
Name der Funktion (aktuelle Parameter)
Name der Funktion
Parameterliste
Lokale Variable
Anweisung
Aufgabe:
Schreiben Sie eine Funktion berechne Rechteck welche als Parameter die Seitenlängen a und
b erhält und in der Funktion den Flächeninhalt berechnet und ausgibt.
Geben Sie zuerst den Prototyp und die Definition der Funktion an, Testen Sie diese
Anschließend in einem Programm.
58
01.09.2003
Funktionen mit einem Rückgabewert

Eine Funktion mit einem Rückgabewert wird beim Prototyp dadurch gekennzeichnet das vor
dem Bezeichner ein Datentyp verschieden von void steht. Nämlich der Datentyp des
Rückgabewertes.
Prototyp:
TypRW <Name> (Parameterliste);
z.B.
double berechneRechteck(double, double);
Definition der Funktion mit Rückgabewert:
Im Quelltext der Funktion muss sich mindestens eine Return- Anweisung befinden, welche
den Wert von dem aufrufenden Programmteil als Konstante, Variable, Ausdruck ausgibt.
Aufruf der Funktion;
Beim Aufruf ist zu beachten das der Rückgabewert der Funktion von einer Variablen vom
gleichen Typ aufgefangen wird dies geschieht über eine Zuweisung der Funktion.
Hinweis:
Mit der Return Anweisung wird die Funktion sofort verlassen
Aufgabe:
Schreiben Sie eine Funktion maximum welche als Parameter 2 int Werte erhält und dem
Größeren zurückgibt.
Geben Sie Prototyp und Definition an bevor Sie die Funktion testen.
Prototyp
int Maximum(int,int);
Definition;
Int Maximum (int a, int b){
If(a>b){
return a;
}
else
{
return b;
}
}
Program:
#include <iomanip>
#include <iostream>
59
01.09.2003
double berechneRechteck (double, double);
void main()
{
double laenge,breite;
cout<<"Bitte geben Sie die Seite a ein!!! : ";
cin>>laenge;
cout<<"Bitte geben Sie die Seite b ein!!! : ";
cin>>breite;
double f;
f=berechneRechteck(laenge,breite);
cout<<"Quadratmeterpreis : "<<f*94.00<<" Euro ";
cout<<endl;
}
double berechneRechteck(double a, double b)

{
double fl=a*b;
cout<<"Der Flaecheninhalt betraegt "<<fl;

return fl;
}
Aufgabe:
Geben Sie den größten Funktionswert der Funktion f(x)=x3-2x+1 im Intervall von –4 bis 4
aus. Der Intervall soll in einer Schrittweite von 0,1 Durchlaufen werden. Eine Funktion soll
die linke und die rechte Intervallgrenze als Parameter erhalten und den größten Funktionswert
zurückgeben.
Program:
#include <iomanip>
#include <iostream>
double maxy (double, double);
void main()
{
double ymax;
ymax=maxy(-4,4);
cout<<"Maximaler Funktionswert : "<<ymax<<endl;
60
01.09.2003
double maxy (double l, double r)

{
double max= l*l*l-2*l*l+1;
for(double x=l;x<= r; x=x+0.01){
double t=x*x*x-2*x+1;
if( t>max){
max=t;
}
}
return max;
}
Aufgabe:
Schreiben Sie eine Funktion ggt, welche zwei natürliche Zahlen als Parameter erhält und den
größten gemeinsamen Teiler der beiden natürlichen Zahlen zurückgibt!
Hinweis:
Verbale Formulierung des Algorithmuses
Die beiden natürlichen Zahlen seien a und b.
Solange a verschieden von b ist tue
wenn a > b ergibt sich aus a-b
sonst ergibt sich aus b-a
a ist ggt von a und b
Program:
#include <iostream>
#include <iomanip>
double ggt(int, int);
void main()
{
int a, b;
cout<<"Eine nat. Zahl: ";
cin>>a;
cout<<"Bitte eine zweite: ";
cin>>b;
double ggt1=ggt(a, b);
61
01.09.2003
cout<<"Das ggt ist: "<<ggt1;
}
double ggt(int a, int b)
{
while(a!=b)
{
if(a>b) a-=b;
else b-=a;
}
return a;
}
Aufgabe:
Schreiben Sie eine Funktion kgv, welche zwei natürliche Zahlen als Parameter erhält und die
kleinste gemeinsame Vielfache der beiden natürlichen Zahlen zurückgibt!
Hinweis:
Die beiden natürlichen Zahlen seien a und b.
Das kgv= (a*b)/ ggt(a,b)
Beispiel:
ggt (32, 12)
a= 32 b=12
a>b a= 32 – 12 = 20
a>b a= 20 – 12 = 8
b>a b= 12 – 8 = 4
a>b a= 8 – 4 = 4
ggt( 32, 12) =4
kgv(32, 12)
a= 32 b=12
kgv= (32*12) /ggt(32,12) = 32*12/4

kgv (32,12)= 96
62
01.09.2003
Program:
#include <iostream>
#include <iomanip>
double ggt(int, int);

double kgv(int, int, int);
void main()
{
int a, b;
cout<<"Eine nat. Zahl: ";
cin>>a;
cout<<"Bitte eine zweite: ";
cin>>b;
double ggt1=ggt(a, b);
cout<<"Das ggt ist: "<<ggt1<<endl;
int kgv2=kgv(ggt1, a, b);

cout<<"Das kgv ist: "<<kgv2<<endl;
}
double ggt(int a, int b)
{
while(a!=b)
{
if(a>b) a-=b;
else b-=a;
}
return a;
}
double kgv(int ggt1, int a, int b)
{
int f;
f=a*b/ggt1;
return f;
}
63
01.09.2003
Funktionen mit Referenzparametern

Eine Funktion mit Referenzparametern kann auch ohne eine Return- Anweisung einen oder
mehrere Werte an den aufrufenden Programmteil zurückgeben.
Referenzparameter werden in der Parameterliste durch ein Kaufmanns und (&)
(Adressoperator) gekennzeichnet.
Beispiel:
Prototyp:
void lies_int (int &);

-
Definition :
Void lies_int (int & a)

{
cout<< « Bitte einen Int- Wert eingeben » ;
cin>> a;
}
Aufruf:
lies_int (zahl);
Beim Aufruf wird der Wert des aktuellen Parameters an den Referenzparameter über dessen
Adresse übergeben, dadurch ändert jede Änderung des Referenzparameters auch den
aktuellen Parameter.
#include <iomanip>
#include <iostream>

void lies_int(int &);
void main()
{
int z;
lies_int(z);
cout<<"Zahl ist : "<<z;
cout<<endl<<endl;
}
void lies_int(int&a)
{
cout<<"Int- Wert eingeben : ";
cin>>a;
64
01.09.2003
Aufgabe:
Ändern Sie die Funktion zur Ermittlung des Wertebereiches so ab das auch das Minimum des
Wertebereiches zurückgegeben wird. Verwenden Sie Referenzparameterwiederholung der
Begriffe der Funktion
Prototyp: legt fest Datentyp des Rückgabewertes, Namen der Funktion, Parameterliste
Definition der Funktion: ist der eigentliche Quelltext der Funktion die Datentypen in der
Parameterliste erhalten Bezeichner und werden in der Funktion als lokale Variablen
verwendet.
Aufruf der Funktion: erfolgt mit dem Namen und den aktuellen Parametern welche im Typ,
Anzahl und Reihenfolge mit der Parameterliste übereinstimmen. Wird eine Funktion mit
Rückgabewert aufgerufen so muss dieser durch eine Variable aufgefangen werden.
Arten von Funktionen:

Funktionen ohne Rückgabewert und Parameterliste
void <Name der Funktion>
Ohne Rückgabewert und mit Parametern

void Bezeichner <Parameterliste>
Hinweis: Parameter können Wert oder Referenzparameter sein
Funktionen mit Rückgabewert und Parameterliste

Typ des Rückgabewertes <Name der Funktion> (Parameterliste)
Parameter:
Aktuelle Parameter heißen die Parameter die beim Aufruf der Funktion verwendet werden.
Wertparameter:
Stehen in der Parameterliste und erhalten den Wert der Aktuellen Parameter als Kopie, sind
sonst normale lokale Variablen der Funktion.
Referenzparameter:
Sind in der Parameterliste durch ein & gekennzeichnet. Erhalten den Wert der aktuellen
Parameter über deren Adresse. Jede Änderung des Referenzparameters ändert auch den
zugehörigen aktuellen Parameter. Sonst lokale Variablen der Funktion.
Aufgabe:
Erstellen Sie eine Wertbelegungstabelle und geben Sie die Ausgabe an! ( Zeigt den Inhalt der
Variablen während der Abarbeitung des Programms.)
65
01.09.2003
Programm:
#include <iostream>
#include <iomanip>
void gemischte_parameter(int&z1,int z3, int&z2)

{
int a=5;
z1=z2+z3;
z2=z1-z2;
z3=z1+a;
}
void main()
{
int a=10, b=20, c=30;
gemischte_parameter(a,b,c);
cout<<"Ausgabe : "<<a<<" "<<b<<" "<<c<<endl;
gemischte_parameter(c,b,a);
cout<<"Ausgabe: "<<a<<" "<<b<<" "<<c<<endl;
}
Wertbelegungstabelle und mit Debugger testen.
Void gemischte_parameter (int& z1, int&z3, int z2, int z4)

{
int a=5, d=12;
z1=z2+z3;
z2=z1-z2;
z3=z1+a;
z4=z3%d+a*4 ;
}
void main()
{
int a=15, b=20 , c=45, d=30 ;
gemischte_parameter (a, b, c, d) ;
cout<< "Ausgabe : "<<a<<" "<<c<<" "<<b;
gemischte_parameter(d, c, b, a),
cout<<“Ausgabe: „<<a<<“ „<<c<<“ „<<b;
}
66
01.09.2003
a b c d Z1(a) Z2 Z3(b) Z4 a d
15 20 45 30
15 45 20 30 5 12
65 65
70 70
30
Ausgabe 65 ,70, 45 ,30
a b c d Z1(d) Z2 Z3(c) Z4
65 70 45 30 30 70 45 65
120 115 115 45 120 20
Ausgabe 65, 120, 70
Programm zum Blatt:

#include <iomanip>
#include <iostream>
#include "console.h"
int ggt(int,int);
int kgv(int,int);
int erw(int, int, int);
int add(int, int);
void kuerze(int, int, int,int&,int&);
void ausgabe(int, int ,int ,int, int, int);
double z1, z2, n1, n2;
void main()
{
system("Title .....:::::Programm zur Bruchrechnung von Bruechen:::::.....");
setColor(15);
cout<<setw(55)<<"Programm zur Bruchrechnung von Bruechen"<<endl<<endl;
setColor(12);
cout<<"Bitte Zaehler von Bruch 1 eingeben : ";
cin>>z1;
cout<<"Bitte Nenner von Bruch 1 eingeben : ";
cin>>n1;
cout<<"Bitte Zaehler von Bruch 2 eingeben : ";
cin>>z2;
cout<<"Bitte Nenner von Bruch 2 eingeben : ";
cin>>n2;
setColor(9);
67
01.09.2003
int gn=kgv(n1,n2);
int nz1=erw(z1,n1,gn);
int nz2=erw(z2,n2,gn);
int sz=add(nz1,nz2);
int kz=ggt(sz,gn);
int en,ez;
kuerze(sz, gn, kz,ez,en);
ausgabe(z1,n1,z2,n2,ez,en);
cout<<endl;
}
//Berechnung des kgv

int kgv( int a, int b)
{
int f;
f=a*b/a;
return f;
}
//Berechnung des ggt

int ggt(int a, int b)
{
while(a!=b)
{
if(a>b){
a-=b;
}
else{
b-=a;
}
}
return a;
}
//Erweitern auf gemeinsamen Nenner
int erw(int z, int n, int gn)
{
int erwz=gn/n;
return erwz*z;
}
//Addition
int add(int z1, int z2)
{
return z1+z2;
}
68
01.09.2003
void kuerze (int sz, int gn, int kz, int& ez, int& en)
{
ez=sz/kz;
en=gn/kz;
}
void ausgabe(int z1, int n1, int z2, int n2, int ez, int en)
{
cout<<endl<<endl;
cout<<setw(35)<<z1
<<--
<<n1<<"+"<<z2
<<--
<<n2<<"="<<ez
<<--
<<en<<endl;
}
Aufgabe:
Erstellen Sie ein Programm zur Bruchrechnung, für die vier Grundrechenarten. Im Bereich
der rationalen Zahlen.
Hinweis: Es werden nur Brüche betrachtet. Lesen Sie Bruch1 und Bruch2 ein und fragen Sie
anschließend in einem die Grundoperation ab. Eine Programmwiederholung soll realisiert
werden. Ist das Ergebnis ein unechter Bruch so soll es nach dem kürzen als gemischte Zahl
angezeigt werden.
Besonderheiten zu Funktionen
Funktionsdeklaration mit Standartwerten
Bei der Deklaration von Funktionen erlaubt C++, einen oder mehrere Parameter mit
Standartwerten vorzubeugen. Beim Aufruf der Funktion kann man diese Parameter
weglassen. Man beachte, dass die fehlenden Parameter die hinteren sein müssen!
z.B. Deklaration
void wdhzeichen (char= ‚*’, int =45); //Prototyp mit Standartwerten
Definition
void wdhzeichen (char ch, int n) //Definition der Funktion
{
for(int i=0; i<n;i++){
cout<<ch;
}
cout<<endl;
}
69
01.09.2003
Aufruf
wdhzeichen( ) ; //Druckt 45 Sterne
wdhzeichen(‘_‘) ; //Druckt 45 Sterne
wdhzeichen(‚+’, 20); //Druckt 20 Pluszeichen
wdhzeichen(20); FEHLER!!!!!
Inline- Funktionen
Um in Kurzen Funktionen Ausführungszeit einzusparen, kann man eine Funktion inline

definieren, welches bewirkt das bei jedem Aufruf der Funktion im Quelltext an Stelle des
Sprunges zur Funktion der tatsächliche Code der Funktion eingefügt wird. Man beachte das
die Funktion vor dem ersten Aufruf definiert sein muss, da sie sonst nicht eingefügt werden
kann!
z.B.
#include.........
Definition und Deklaration zusammen

Inline void whhzeichen (char ch, int n) //inline- Definition der Funktion
{
for(int i=0; i<n; i++){
cout<<ch;
}
cout<<endl;
}
main( ) //muss der Definition einer inline

{ //Funktion folgen
…..
wdhzeichen(‘*’,45) ; //hier wird Quelltext eingefügt
}
Überlagerte Funktion
Eine überlagerte Funktion führt, abhängig von der Art der an sie übermittelten Daten,
unterschiedliche Aktionen durch. Man kann mehrere Funktionen mit dem gleichen Namen
deklarieren und definieren ohne eine Fehlermeldung zu erhalten, wenn die Argumente der
Funktionen verschieden sind.
Für die Signifikanz einer Funktion ist der Name und die Parameterliste entscheidend (ähnlich
wie bei Vor- und Nachnamen von Personen)
Aufgabe:
Schreiben Sie eine Funktion Maximum welche 2 integerwerte enthält und den größten der 2
Werte zurückgibt. Schreiben Sie analog der eine Funktion für Double Werte. Teste Sie die
Funktion im Praogramm.
70
01.09.2003
Programm:
#include <iostream>
#include <iomanip>
double maximum(double, double);

int maximum(int, int);
void main()
{
int a,b;
cout<<"Bitte int Wert eingeben : ";
cin>>a,
cout<<"Bitte weiteren int Wert eingeben : ";
cin>>b;
int erg=maximum(a,b);
cout<<"Maximum der Inwerte : "<<erg<<endl;
double z1, z2;
cout<<"\n\nBitte double Wert eingeben : ";
cin>>z1,
cout<<"Bitte weiteren double Wert eingeben : ";
cin>>z2;
double ez=maximum(z1,z2);
cout<<"Maximum der Doublewerte : "<<ez<<endl;
double maximum(double a, double b)

{
if(a>b){
return a;
}
else{
return b;
}
}
int maximum(int a,int b)
{
if(a>b){
return a;
}
else{
return b;
}
71
01.09.2003
Konstante Wert und Referenzparameter

Es kommt öfter das bei Funktionen die Wert oder Referenzparameter in der Funktion nicht
geändert werden können. Man setzt vor den Datentyp den Spezifiziere Konst um dies zu
erreichen.
Frage: Warum legt man auch konstante Referenzparameter an (in seltenen Fällen, diese sollen
sich ja ändern um den aktuellen Parameter zu verändern).
Rekursikon:
Das besondere daran ist, dass in der Definition von fact bereits die zu definierende Funktion
verwendet wird. Eine solche Definition heißt Rekursion. Die Berechnung der Fakultät der
Zahl
n wird auf die Berechnung der Fakultät n – 1 zurückgeführt.
Die Funktion fact besteht aus eine bedingten Anweisung, die im Falle von n größer als 0,
wieder die Funktion fact, nun n – 1, aufruft.
Rekursive Berechnung der Fakultät:

long fact(long n)
{
if(n==0){
return 1;
}
else{
return n * fact(n -1);
}
}
Rekursion:
Rekursive Algorithmen zeichnen sich dadurch aus, das es Funktionen gibt die sich innerhaslb
ihres Funktions- Rumpfes selbst wieder aufrufen.
Rekursive Algorithmen können daher immer auf Probleme angewandt werden, die sich auf
ein gleichartiges, aber einfaches Problem zurückführen lassen. Und es muss eine Lösung für
ein elementares Problem existieren.
72
01.09.2003
Rekursive Aufrufe der Funktion fact zur Berechnung von 4!
Aufrufe Rückgabe
fact(4) = 4 * fact(3) = 4 * 6 = 24
fact(3) = 3 * fact(2) = 3*2=6
fact(2) = 2 * fact(1) = 2*1=2
fact(1) = 1 * fact(0) = 1*1=1
fact(0) = 1
Die richtige Durchführung der Berechnung organisiert der Computer mit Hilfe unserer
rekursiven Definition automatisch.
Program:
#include <iostream>
#include <iomanip>
long fact(long);
void main()
{
system("Title Berechnung der Fakultaet by Sebastian Wetzel");

long x;
cout<<"Bitte Zahl Fakultaet eingeben : ";
cin>>x;
cout<<fact(x);
}
long fact(long n)
{
if(n==0){
return 1;
}
else{
return n * fact(n -1);;
}
}
73
01.09.2003
Grundgerüst einer Rekursiven Funktion

.............rekursin(......)
{
if(„wenn Problem kleiner genug Abbruchkriterium erreicht){
// nicht rekursiver Zweig
}
else{
//rekusiver Zweig mit verkleinertem Problem
}
}
1. Aufgabe
Berechnen Sie die Funktion „Summe der ersten, natürlichen Zahlen“ rekursiv! Betrachten Sie
dazu das Programm zur Berechnung der Fakultät.
Program:
#include <iomanip>
#include <iostream>

long summe (long n);
void main()
{
system("Title Summe Rekursiver Funktionen");
long y;
cout<<"Bitte Zahl eingeben : ";
cin>>y;
cout<<summe(y)<<endl;
}
long summe(long n)
{
if (n==0){
return 0;
}
else{
return n+summe(n-1);
}
}
Eigenschaften von Rekursiven Algorithmen:

• Rekursive Algorithmen rufen sich immer wieder selbst auf es entstehen mehrere
Modulexemplare die sich gleichzeitig im Hauptspeicher befinden
• Rekursive Algorithmen müssen eine eindeutige Abbruchbedingung besitzen in
welcher sich der Algorithmus nicht wieder selbst aufruft
• Der Speicherbedarf für rekursive Algorithmen wird um so höher je größer die Anzahl
der Aufgerufenen Modul Exemplare ist
74
01.09.2003
• Lokale Daten werden bei rekursiven Algorithmen in einer LIFO Struktur (Last in First
out) auf dem Systeminternen Stack gespeichert (ein Stack überlauf ist möglich und
wenn keine Abbruchbedingung unausweichlich)
2. Aufgabe: Fibonacci – Folge

Berechnen Sie die Glieder der Fibonacci- Folge!
0 für n=0
fibo(n)=1 für n=1
a(n-1)+a(n-2) für n>1
Program:
#include <iostream>
#include <iomanip>

long fibo(long);
void main()
{
system("Title Berechnung von Fibo");
long f;
cout<<"Bitte Fibo eingeben : ";
cin>>f;
cout<<fibo(f)<<endl;
}
long fibo(long n)
{
if(n==0){
return 0;
}
if(n==1){
return 1;
}
if(n>1){
return fibo (n-1)+fibo(n-2);
}
}
75
01.09.2003
Rekursikon und Iteration

Unter Iteration versteht man die Programmierung von Wiederholungen mit Hilfe der
Wiederholungsanweisung for, While und do- While.
Rekursikon ist die Programmierung von Wiederholung in dem sich die Funktion im
Funktionskörper wieder selbst aufruft.
Es gilt Jede Wiederholung lässt sich sowohl Iterativ als auch Rekursiv programmieren.
Aufgabe:
Schreiben Sie eine Funktion welche Rekursiv die Quadratzahlen von 1 bis 10 auf dem
Bildschirm ausgibt.
Program:
#include <iostream>
#include <iomanip>

void quadrat(int);
void main()
{
int x;
cout<<"Bitte Zahl eingeben : ";
cin>>x;
system("Title Berechnung der Quadratzahlen mit Rekursiven Funktionen");
quadrat(x);
}
void quadrat(int n)
{
if(n>=0){
quadrat(n-1);
cout<<endl<<n*n;
}
cout<<endl;
}
Aufgabe:
Der größte Gemeinsame Teiler zweier Zahlen läst sich auch sehr schön Rekursiv berechnen.
Schreiben Sie eine Funktion ggt, welche Rekursiv den Größten gemeinsamen Teiler
berechnet. Schreiben Sie zuerst die Rekursive Formel für ggt auf.
Formel
a wenn a= =b
ggt(a, b)= ggt(a, b –a) wenn b>a
ggt (a-b, b) wenn a>b
76
01.09.2003
Program:
#include <iostream>
#include <iomanip>

long rekggt(long, long);
void main()
{
long y,x;
system("Title Berechnung der ggt mit Rekursiven Funktionen");
cout<<"Bitte a eingeben : ";
cin>>x;
cout<<"Bitte b eingeben : ";
cin>>y;
long erg=rekggt(x,y);
cout<<"ggt :"<<erg<<endl;
}
long rekggt(long a, long b)
{
if(a>b){
return rekggt(a-b,b);
}
if(b>a){
return rekggt(a,b-a);
}
if(a==b){
return a;
}
}
Static Variablen in Funktionen

Deklariert man eine Variable mit dem Spezifizierer static so wird diese Variable nach dem
verlassen der Funktion zwischengespeichert d.h. sie behält bis zum nächsten Aufruf ihren
Wert.
Beispiel:
Schreiben Sie eine Funktion mit einer static Variable welche sich im Quelltext der Funktion
um 1erhöt und vor dem verlassen der Funktion auf dem Bildschirm ausgegeben wird. Rufen
Sie die Funktion mehrfach auf und beobachten Sie das Verhalten.
Program:
#include <iomanip>
#include <iostream>

void statikfkt()
{
77
01.09.2003
static int n=0;

n+=1;
cout<<n<<endl;
void main()
{
system("Title static Variablen in Funktionen");
for(int i=1;i<=10;i++)
{
statikfkt();
}
Felder in C++
Ein Feld besteht aus Elementen desselben Datentyps. Das einzelne Element trägt keinen
Namen, sondern wird über die Position im Feld den Index erreicht.
Deklaration eines Feldes

<Typangabe> Bezeichner[Anzahl];
Anzahl legt fest, wie viele Elemente in einem Feld enthalten sind. Sie muss in eckigen
Klammern [] stehen. Der Wert von Anzahl muss ein konstanter Wert sein.
Beispiel:
const int Anz=10; //Festlegung einer Konstanten zur Dimension
int zahl[Anz]; //Integer-Feld mit 10 Elementen
float temp[5]; //Float-Feld mit 6 Elementen
Zugriff auf Elemente des Feldes
Der Zugriff erfolgt über den Index, dieser wird in den eckigen Klammern angegeben und
beginnt bei Feldern stets mit dem Index 0. Das heißt, dass letzte Feldelement hat den Index
Anzahl -1.
Beispiel:
temp[0]=0.4; temp[1]=0.3; temp[2]=1.4 ; temp[3]=2.6 ; temp[4]=0.2 // OK
temp[5]=1.3 ; !!!Falsch !!!!! überschreibt Speicher ohne Warnung
78
01.09.2003
Initialisierung von Feldern

Ein Feld kann bei der Definition mit einer durch Kommata getrennten Liste von Werten
initialisiert werden, welche in geschweiften Klammern { } steht, Die Anzahl der Elemente
braucht nicht angegeben werden.
z.B.
int wuerfelzahl[]= {1, 3, 4, 6, 3, 2, 1} //Feld mit 7 Elementen
Hinweis: Wird eine Anzahl von Elementen angegeben darf dieses nicht überschritten
werden.
z.B.
int wuerfelzahl[3]={1, 3, 4} //Feld mit 3 Elementen OK

int wuerfelzahl[3]={1, 3, 4, 2} //FEHLER zu viele Elemente
int wuerfelzahl[3]={1} //Feld mit 3 Elementen, wobei das 1. Element mit 1
//initialisiert die anderen mit 0
Effektiver Zugriff auf ein Feld mit einer for – Schleife

Ein Effektiver Zugriff auf die Elemente eines Feldes erfolgt mit Hilfe einer for- Schleife bei
welcher die Zählvariable (z.B. i) verwendet wird um alle Feldelemente anzusprechen. Z.B.
füllen eines Integer Feldes mit Zufallzahlen zwischen 1 und 100.
// Zufallsgenerator initialisieren
// long t;
// Srand( time (&T));
const int Anz = 100;
int zufall [Anz];
for(int i=0; i< Anz; i++){
zufall[i]= rand% 100+1;
}
Aufgabe:
Schreiben Sie ein Programm welches ein Feld mit Zufallszahlen zwischen 1 und 100 füllt und
dieses in einer 2 Schleife mit einer Ausgabenbreite von 8 ausgibt.
Program:
#include <iomanip>
#include <iostream>
#include <conio.h>
#include <ctime>
#include <cstdlib>
void main()
{
// Zufallsgenerator initialisieren
long t;
srand( time (&t));
79
01.09.2003
const int Anz = 100;

int zufall [Anz];
for(int i=0; i< Anz; i++){
zufall[i]= rand()%100+1;
}
for(int j=0;j<Anz;j++){
cout<<setw(8)<<zufall[j];
}
}
Aufgabe:
Eine Wetterstation erhält Temperaturdaten von 5 verschiedenen Wetterballons. Diese Daten
sollen in einem Feld gespeichert werden und anschließend ist a) der Durchschnitt der
Temperaturen zu berechnen und auszugeben.
Program:
#include <iomanip>
#include <iostream>
void main()
{
const int anz=5;
double ball[anz];
for(int i=0; i<anz;i++){

cout<<setw(2)<<i+1<<" "<<"Bitte Temperatur eingeben ";
cin>>ball[i];
}
double summe=0.0;
for( i=0; i<anz;i++){
summe+=ball[i];
}
double durchschnitt=summe/anz;
cout<<endl<<"Durchschnittstemperatur :"<<durchschnitt<<endl;
b) Ausgabe der Maximal bzw. Minimal Temperatur.
Hinweis:
Ermittlung der Maximaltemperatur :
• Variable Maximum vom Typ des Feldes anlegen und mit dem Wert des ersten
Feldelementes Initialisieren
• Vergleich von Maximum mit allen nachfolgenden Feldelementen, ist ein
nachfolgendes Feldelement größer so wird es neues Maximum
• Ausgabe von Maximum
80
01.09.2003
• Vergleichen von Minimum mit allen nachfolgenden Feldelementen, ist ein

nachfolgendes Feldelement kleiner so wird es neues Minimum
• Ausgabe von Minimum
double maximum=ball[0];
for(i=1; i<anz;i++){
if(ball[i]>maximum){
maximum=ball[i];
}
}
cout<<"Das Maximum betraegt : "<<maximum<<endl;
double minimum=ball[0];
for(i=1; i<anz;i++){
if(ball[i]<minimum){
minimum=ball[i];
}
}
cout<<"Das Minimum betraegt : "<<minimum<<endl;
Sortieren von Feldern
Sortieren durch Austausch:
Man vergleicht das erste Feldelement mit allen nachfolgenden Feldelementen. Ist eine
nachfolgendes Feldelement kleiner so tausch es mit dem ersten Feldelement den Platz.
Ergebnis: das kleinste Feldelement steht am ersten Platz.
Dann vergleicht man das zweite Feldelement mit allen nachfolgenden Feldelementen. Ist ein
nachfolgendes Feldelement kleiner, so tauscht es mit dem zweiten Feld den Platz.
Ergebnis: das zweitkleinste steht am zweiten Platz.
So verfährt man bis zum vorletzten Feldelement.
81
01.09.2003
Def.:
for(int i=0;i<anz+1;i++){
for( int j=i+1; j<anz;j++){
if(feld[i]> feld[j]){
int hilf= feld[i];
feld[i]= feld[j];
feld[j]= hilf;
}
}
}
Aufgabe:
Initialisieren sie ein int- Feld mit den Werten aus dem Beispiel. Sortieren Sie das Feld und
geben Sie anschließend das sortierte Feld auf dem Bildschirm aus.
#include<iostream>
#include<conio.h>
void main()
{
int feld[]={3,4,2,1,7};
const int anz=5;
for(int i=0;i<anz-1;i++){
for( int j=i+1; j<anz;j++){
if(feld[i]> feld[j]){
int hilf= feld[i];
feld[i]= feld[j];
feld[j]= hilf;
}
}
for(int t=0;t< anz;t++){
cout<<" "<<feld[t];
}
cout<<endl;
getch();
}
}
82
01.09.2003
Beispiele:
Bubble-Sort (Sprudelmethode)
Beschreibung:
Beginnend mit dem 1. Element werden fortlaufend je zwei benachbarte Elemente verglichen
und dann vertauscht, wenn die nicht in der richtigen Reihenfolge stehen.
Dieser „Durchlauf“ wird solange wiederholt, bis keine Vertauschung mehr erforderlich ist.
Man erkennt, dass

nach dem 1. Durchlauf das größte Element außen rechts steht
nach dem 2. Durchlauf steht das zweitgrößte Element richtig
nach dem 3. Durchlauf steht das drittgrößte Element richtig usw.
Große Elemente haben also die Neigung, wie Luftblasen aufzusteigen.
Wiederhole:
Sortiert:= wahr;
Für von 0 bis <n-1
wenn a[i]>a[i+1]
vertausche a[i] mit a[i+1]
sortiert= falsch
do{
sortiert=1;
for(int i=0;i<anz-1;i++){
if( feld[i]>feld[i+1]){
int hilf=feld[i];
feld[i]=feld[j];
feld[j]=hilf;
sortiert=0;
}
} while(sortiert==0);
Aufgabe:
Schreiben Sie ein Beispielprogramm in welchem Sie eine Funktion Bubble- Sort realisieren
welche als Parameter ein Feld von Integer werten erhält und als zweiten Parameter die Anzahl
der Elemente des Feldes erhält.
83
01.09.2003
Übergabe von Feldern an Funktionen

1 Felder als Funktionsparameter sind grundsätzlich Referenzparameter.
2 Eine Spezielle Kennzeichnung durch & entfällt dadurch.
Ein Feld als Referenzparameter wird durch den Datentyp und [ ] gekennzeichnet die
Angabe einer Dimension entfällt. In der Regel wird die Anzahl der Elemente als 2.
Parameter übergeben.
z.B.
Prototyp: void bubblesort (int [ ], int)
Definition der Funktion:

Die Parameter erhalten Bezeichner
void bubblesort(inte f[], int anz)

{
int sortier =0;
do{
sortiert=1;
for(int i=0;i<anz ;i++){
if( f[i]>f[i+1]){
int hilf=f[i];
f[i]=f[j];
f[j]=hilf;
sortiert=0;
}
while (sortier = =0);
}
tausch des Feldes
sortier= 0;
3. Wird ein Feld beim Aufruf einer Funktion als Aktueller Parameter übergeben, so wird
nur der Name des Feldes angegeben. Denn der Name des Feldes ist in C identisch mit
der Anfangsadresse des Feldes.
Hinweis: zum Testen der Funktion Bubble- Sort füllen Sie in der Funktion Main ein Feld
mit 100 Zufallszahlen.
Program:
#include <iomanip>
#include <iostream>
#include <ctime>
#include <cstdlib>
void ausgabe(int[],int);
void zufallszahlen(int[], int);
void bubblesort(int [ ], int);
84
01.09.2003
void main()
{
const int Anz=100;

int zufall[Anz];
zufallszahlen(zufall,Anz);
bubblesort(zufall,Anz);
ausgabe(zufall,Anz);
}
void ausgabe(int zufall[], int Anz)
{
for(int j = 0;j<Anz;j++){
cout<<setw(4)<<zufall[j];
}
}
void zufallszahlen(int zufall[],int Anz)

{
long t;
srand( time (&t));
for(int i = 0; i< Anz; i++){

zufall[i] = rand()%100+1;
}
}
void bubblesort(int f[], int anz)

{
int sortier = 0;
do{
sortier = 1;
for(int i=0;i<anz ;i++){
if( f[i]>f[i+1]){
int hilf = f[i];
f[i] = f[i+1];
f[i+1] = hilf;
sortier = 0;
}
}
}while (sortier ==0);
85
01.09.2003
Hinweis zu Bubble- Sort:

Der Algorithmus wird effizienter , wenn man beachtet das bei jedem Durchlauf das größte
Element nach hinten wandert. Man erreicht dies durch einfügen der Anweisung anzahl-1 am
ende der for- Schleife.
Effizienz von Sortierverfahren:

Man kann die verschiedenen Sortierverfahren an hand der folgenden Kriterien auf effiziens
vergleichen.
1. Anzahl der benötigten Vergleichs- und Austauschoperatoren in Abhängigkeit von der
Anzahl der zu sortierenden Elemente.
2. Bedarf an zusätzlichen Speicherplatz während des Sortierens
Effizinsbetrachtung von Bubble- Sort

Anzahl der Vergleiche: ergibt sich aus der (Anzahl der ElementeC
Anzahl der Austauschoperationen: ergibt sich ebenfalls aus (Anzahl der Elemente)2 /2
(abhängig vom Sortierungsgrad)
Selection Sort
Sortieren durch direkte Auswahl.
Algorithmus:
Finde zuerst das kleinste Element der Datenmenge und tausche es gegen das Feld an platz null
aus.
Finde danach das zweitkleinste Element und tausche es gegen das Feld an Platz eins aus.
Usw. bis das Feld sortiert ist.
Selection Sort
Daten[], anz
Für i von 0 bis anz -2
min = i
Für i von i+1 bis anz -1
Daten[j]< Daten[min]
W F
min=j
Tausch = Daten [min]
Daten[min]= Daten [i]
Daten[i]= tausch
86
01.09.2003
Währe der Index i vom Anfang bis zum Ende durch das Datenfeld wandert befinden sich die
Elemente links von Platz i auf ihrer entgültigen Position im Datenfeld.
Selection Sort ist eine einfache Sortiermethode für kleine Datenmengen da jedes Element
höchstens nur einmal getauscht wird.
Effizienzbetrachtung von Selektion Sort
Anzahl der Vergleiche: (Anzahl der Elemente)2 /2

Anzahl der Tauschoperatoren = Anzahl der Elemente
Aufgabe schreiben Sie die Funktion Selection Sort anhand des Strucktogrammes
#include <iostream>
#include <iomanip>
#include <ctime>
void selectionsort(int f[], int n)

{
for(int i=0; i<=n-2; i++)
{
int min=i;
for(int j=i+1; j<=n-1; j++)
{
if(f[j] < f[min])
{
min=j;
}
}
int hilf=f[min];
f[min]=f[i];
f[i]=hilf;
}
}
void zufall(int f[], int n)

{
long t;
srand(time(&t));
for (int i=0; i<n; i++)
{
f[i]=rand()%n+1;
}
}
87
01.09.2003
void ausgabe(int f[], int n)

{
{
cout<<setw(4)<<left<<f[i]<<" ";
}
cout<<endl;
}
void main()
{
const int Anz=100;
int Feld[Anz];
zufall(Feld, Anz);
selectionsort(Feld, Anz);
ausgabe(Feld, Anz);
}
Suche
Sequentielle Suche
Liegt eine Sammlung von Daten vollkommen unsortiert vor, dann kann man nach einem
bestimmten Datensatz nur sequentiell suchen d.h. Jeder einzelne Datensatz muss
nacheinander darauf hin betrachtet werden, ob er den Suchbedingungen genügt.
Sein Effizienz ist vollständig vom Zufall abhängig.
Ablauf:
• Suchbegriff bzw. Schlüssel einlesen
• Schlüssel mit allen Daten fortlaufend vergleich
• Wenn Schlüssel gleich Datensatz
• Ausgabe gefunden
Aufgabe:
Schreiben Sie eine Funktion Sequen_Suche( ), welche als Parameter ein Feld, die Anzahl der
Elemente und den Suchschlüssel erhält und festgestellt ob der Schlüssel vorhanden ist.
Program:
#include <iostream>
#include <iomanip>
#include <ctime>
void sequen_suche(int f[],int anz,int s)

{
int g=-1;
for(int i=0;i<anz;i++){
88
01.09.2003
if(s==f[i]){
cout<<"gefunden an Position "<<i<<" ";
g=1;
}
}
if(g!=1){
cout<<"Element nicht vorhanden ";
}
}
void zufall(int f[], int n)
{
long t;
srand(time(&t));
{
f[i]=rand()%n+1;
}
}
void ausgabe(int f[], int n)

{
{
cout<<setw(4)<<left<<f[i]<<" ";
}
cout<<endl;
}
void main()
{
const int Anz=100;
int Feld[Anz];
zufall(Feld, Anz);
sequen_suche(Feld,Anz,5);
ausgabe(Feld, Anz);
}
Binäres Suchen
Deutlich effektiver kann man arbeiten, wenn die Datenmengen nach dem Suchschlüssel
sortiert vorliegt.
Ablauf:
1. Man nimmt an, dass anz Datensätze nach dem Schlüssel sortiert vorliegen.
2. Man betrachtet zunächst das Schlüsselelement im Datensatz genau in der Mitte. anz/2
3. Ist das betrachtete Datenelement kleiner als der gesuchte Schlüssel, betrachten wir
lediglich noch die Datensätze von 0 bis anz/2 –1, ist er größer, von anz/2+1bis anz –1.
89
01.09.2003
4. Die Schleife 2-3 wiederholt man solange, bis der Suchbegriff gefunden wurde oder die
Betrachtungsmenge auf ein Element geschrumpft ist, dass den Suchbegriff nicht
enthält. Suchbegriff nicht enthalten!!!
Binaeres_Schen
Daten[ ], anz, suchw
anf=0;ende= anz -1
X= (anf+ende)/2
Suchw<Daten[x]
WAHR FALSCH
Ende=X-1
Solange suchw != Daten[x] && anfg<= ende

suchw= = Daten[x]
WAHR FALSCH
Gefunden an Position x! Nicht gefunden!
void binares_suchen(int f[], int n, int schluessel)

{
int anf=0;
int ende=n-1;
int x;
do
{
x=(anf+ende)/2;
if (schluessel<f[x])
{
ende=x-1;
}
else
{
anf=x+1;
}
} while(schluessel!=f[x] && anf<=ende);
if (schluessel==f[x])
{
cout<<"Gefunden an Position "<<x<<endl;
}
else
{
cout<<"Nicht gefunden!"<<endl;
}
}
90
01.09.2003
Vergleich der Suchalgorithmen:
Bei linearer Suche:
Anzahl der Vergleiche geht gegen Anzahl der Elemente.
Binäre Suche:
Anzahl der Vergleiche geht gegen ln von n zur Basis 2
Zweidimensionale Felder
Ein Zweidimensionales Feld ist vorstellbar als Tabelle aus Zeilen und Spalten. Ein Index des
Feldes ist demnach die Zeile, der andere Index ist die Spalte.
z.B. const int Zeile = 3;

const int Spalte = 5;
int f[Zeile] [Spalte]; //int Feld besteht aus 3Zeilen und 5 Spalten
Effektiver zugriff auf Zweidimensionale Felder.
Erfolgt über zwei verschachtelte for- Schleifen wobei die äußere Schleife den Zeilenindex
entsprechen sollte.
z.B.
for(int i=0; i<Zeile; i++){
for(int j=0;j<Spalte; j++){
cin>>f[i][j];
}
}
Übergabe von zweidimensionalen Felder an Funktionen.
Bei der Übergabe ist zu beachten das bei der Angabe des Feldparameters nur die erste
Dimension (der Zeile) leer bleiben darf. Die Spaltendimension muss angegeben werden.
Aufgabe:
Schreiben Sie ein Funktion Zufall welche als Parameter ein Zweidimensionales Feld erhält
mit 3 Zeilen und 5 Spalten sowie Zwei Parametern vom Typ int Zeile und Spalte. Füllen sie
das Feld mit Zufallszahlen.
Schreiben Sie eine Funktion Ausgabe mit gleichen Parametern welche das Feld Zeilenweise
ausgibt.
Programm:
#include <iomanip>
#include <iostream>
#include <ctime>
91
01.09.2003
#include <cstdlib>
const int Zeile=3;
const int Spalte=5;
void zufall(int feld[Zeile][Spalte],int , int );

void ausgabe(int feld[Zeile][Spalte],int, int);
void main()
{
int feld[Zeile][Spalte];
zufall(feld,Zeile,Spalte);
ausgabe(feld,Zeile,Spalte);
void zufall(int feld[Zeile][Spalte],int Zeilen, int Spalten)

{
long t;
srand( time (&t));
for(int i=0; i< Zeilen; i++){

for(int j=0; j< Spalten; j++){
feld[i][j]= rand()%100+1;
}
}
}
void ausgabe( int feld[Zeile][Spalte],int d,int f)

{
cout<<endl;
for(int x=0; x< d; x++){
for(int y=0; y< f; y++){
cout<<setw(8)<<feld[x][y];
}
cout<<endl;
}
92
01.09.2003
Zeichenketten in C
Unter Zeichenketten (String) versteht man ein Feld von Einzelzeichen (Datentyp Char)
welches man üblicherweise als zusammenhängende Folge von Zeichen verarbeitet.
Definition einer Zeichenkette:
const int Max=80;

char zk[Max];
Initialisierung einer Zeichenkette:

char str[] = „Dies ist eine Zeichenkette“
Beachte:
Zeichenketten in C++ erhalten automatisch ein abschließendes Nullzeichen ‚\0’. Dadurch
lassen sich nur 79 Zeichen speichern.
Eingabe von Zeichenketten:

Zeichenketten können mit cin und zweimal dem
Eingabeoperator und einem Bezeichner eingelesen werden.
Um eine Zeichenkette mit Trennzeichen einzulesen verwendet man die
Funktion gets( ); aus der Bibliothek <cstdio>.
Beachte:
Cin liest die Zeichenkette nur bis zum ersten Leer- / Trennzeichen ein.
Die Eingabe einer Zeichenkette darf nicht größer als die reservierten
Speicherstellen sein.
Ausgabe von Zeichenketten

Ausgabe mit cout oder puts(Bezeichner).
Hinweis:
Möchte man die Zeichenkette Elementweise über eine for- Schleife einlesen so muss man als
Letztes Zeichen die Endekennung von selbst anwenden. Auch eine Ausgabe ist Zeichenweise
über eine for- Schleife mögliche.
Funktionen zur Manipulation bzw. zur Bearbeitung von

Zeichenketten stehen in der <cstring>
Informieren Sie sich in der Hilfe über folgende Funktionen zur Manipulation:
• Länge einer Zeichenkette
• Umkehren einer Zeichenkette
• Anhängen einer Zeichenketten
• Kopieren einer Zeichenkette
• Vergleichen
• Umwandeln in Kleinbuchstaben
• Umwandeln in Großbuchstaben
Achten Sie besonders auf die Parameter der Funktionen.

93
01.09.2003
Länge einer Zeichenkette bestimmen

Syntax: strlen(<Bezeichner>);
Rückgabe: Anzahl der Zeichen als int
Berspiel: char ZK[] = „Hallo“;
cout<<“Die Zeichenkette hat: “<<strlen(ZK)<<“Buchstaben“;
//Die Ausgabe ist dann 5
Kopieren einer Zeichenkette

Syntax: strcpy(<neue Zeichenkette>, <Ursprungs-Zeichenkette>);
Beachte: Die Anzahl der reservierten Speicherstellen, der neuen Zeichenkette,
muss mindestens gleich der alten Zeichenkette sein!
Beispiel: char erste_ZK[] = “Hallo“, zweite_ZK[10];
strcpy(zweite_ZK, erste_ZK);
cout<<zweite_ZK; //Ausgabe: Hallo
Vergleichen von 2 Zeichenketten

Syntax: strcmp(<Bezeichner 1>, <Bezeichner 2>);
Rückgabe: einen int Wert
< 0 wenn erster Bezeichner < als zweiter Bezeichner
0 wenn Bezeichner = als zweiter Bezeichner
> 0 wenn Bezeichner > als zweiter Bezeichner
Beispiel: char ZK1[15], ZK2[15];
cout<<“erste Zeichenkette (nicht mehr als 15 Zeichen): “;
gets(ZK1);
cout<<“zweite Zeichenkette (nicht mehr als 15 Zeichen): “;
gets(ZK2);
int vergl = strcmp(ZK1, ZK2);
if( vergl == 0 ) cout<<“Sie haben zweimal das gleiche eingegeben!“;
else cout<<“Ihre beiden Eingaben sind Unterschiedlich!“;
ändern von Großbuchstaben in kleine

Syntax: strlwr(<Bezeichner>);
Beispiel: char ZK[] = “HALLO“;
strlwr(ZK);
cout<<ZK; //Ausgabe: hallo
ändern von Kleinbuchstaben in große

Syntax: strupr(<Bezeichner>);
Beispiel: char ZK[] = “hallo“;
strupr(ZK);
cout<<ZK; //Ausgabe: HALLO
anhängen einer Zeichenkette an eine andere

Syntax: strcat(<erster Bezeichner>, <zweiter Bezeichner>);
Beispiel: char zk1[] = “Sebastian= “der Master“;
strcat(zk1, zk2);
cout<<zk1; //Ausgabe: ’Sebastianer’
94
01.09.2003
Umkehren Zeichenkette
Syntax: strrev(<Bezeichner>);
Beispiel: char zk[] = “Hallo“;
strrev(zk);
cout<<zk; //Ausgabe: ollaH
Aufgabe:
Lesen Sie eine Zeichenkette ein und geben Sie anschließend die Länge
der Zeichenkette aus, danach überprüfen Sie ob die Eingegebene
Zeichenkette ein Pallintron (von beiden Seiten gelesen die gleiche
Bedeutung z.B. Otto, Anna) ist.
Program:
#include<iostream>
#include<stdio.h>
#include<string>

void main()
{
char zk[999], zk2[999];

cout<<"Bitte einen Text: ";
gets(zk);
int l=strlen(zk);
cout<<"Die Länge ist: "<<l<<endl;
strupr(zk);
strcpy(zk2, zk);
strrev(zk2);
int vergl=strcmp(zk, zk2);
if(vergl==0)
{
for(int i=0; i<l; i++)
cout<<zk2[i];
cout<<"\nKann man in beide Richtingen schreiben";
}
else cout<<"\nSchön!";
Aufgabe:
Deklarieren Sie ein Feld welches Zeichenketten aufnehmen kann (maximale Länge 80
Zeichen) Schreiben Sie anschließend eine Funktion Eingabe welche 8 Namen einließt eine
Funktion Ausgabe welche die Zeichenketten ausgibt und eine Funktion Sortieren welche die
Zeichenketten Alphabetisch sortiert.
Hinweis der Zeichenketten in Großbuchstaben
95
01.09.2003
Besonderheiten von Feldern

Felder von Zahlen (int, double, float)
Werden über den Index angesprochen und Elementweise bearbeitet. Mathematische
Operationen sind auf die einzelnen Elemente anwendbar, entsprechend des Datentyps.
Zeichenketten Felder (strings)

Werden als ganzes über den Namen des Feldes angesprochen. Besitzen eine ende Kennung.
Operatoren bzw. Funktionen für Zeichenketten befinden sich in der <cstring> wie z.B. strlem,
strcmp. strcpy.
Allgemein
Der Programmierer muss darauf achten das bei Feldern vom Compiler keine
Bereichsüberprüfung stattfindet.
Mehrdimensionale Felder
Erhält man durch zufügen einer weiteren Eckigen Klammer mit Dimensionsangabe. Erste
Dimension entspricht immer den Zeilen
Zeitmessung
Funktionen zur Zeitmessung clock ( ) <ctime>
Liefert uns die vergangenen Milisekunden seit dem letzten Aufruf von clock.
Aufgabe:
Schreiben Sie eine Funktion Zeitanzeige welche als Parameter die Zeit in Milisekunden erhält
und in der Funktion die Milisekunden in Stunden : Minuten : Sekunden : Milisekunden
ausgibt.
Funktion GetTickCount( ) <windows.h>

Liefert die vergangenen Milisekunden seit dem einschalten des PC. Als long Wert.
Hinweis: benötigte Variablen siehe Aufgabe 1.
Aufgabe:
Erstellen Sie ein Beispielprogramm und rufen Sie die Funktion zur darstellen der Zeit auf.
#include <iomanip>
#include <iostream>
#include <ctime>
#include <conio.h>
void main()
{
96
01.09.2003
long anf, ende ,zeit,sek,min,st,ms;

anf=clock();
getch();
ende= clock();
zeit=ende-anf;
st=zeit/360000;
min=zeit/6000-st*60;
sek=zeit/1000-min*60;
ms=zeit-sek*1000;
cout<<st<<" : "<<min<<" : "<<sek<<" : "<<ms;

}
Struckturen
Eine Struktur ist eine Sammlung einfacher Variablen, welche unterschiedlichen Datentypen
besitzen können und Komponenten der Struktur genannt werden.
Syntax:
Struct Tbezeichner{
DT Bezeichner;
DT Bezeichner;
};
Bsp. Struktur einers Kontoauszuges
Struct Tauszug{
Long kontonr;
Char name[30];
Double stand;
Hinweis:
Da Tauszug nur ein neuer eigener Datentyp ist habe ich keinen Zugriff auf die
Struckturkomponenten. Dazu muss ich erst eine Variable vom Typ Tauszug anlegen.
Anlegen einer Structurvariablen

Syntax:
Tbezeichner Variablenbezeichner;
z.B.
Tauszug konto;
Hinweis:
97
01.09.2003
Die Variable Konto nutzt mir nichts alleine da ich dem Compiler noch mitteilen muss welche
strukturkomponente ich verwenden möchte.
Zugriff auf Strukturkomponenten
Erfolgt über den Punktoperator.
Syntax:
Variablenbezeichner.Bezeichner Strukturkomponente
z.B.
Konto.Kontonr=12345;
Aufgabe:
Deklerieren Sie eine Struktur Tauszug mit den vorgegebenen Komponenten (siehe oben).
Legen Sie eine Variable vom Typ Tauszug an, lesen Sie anschließend Werte für die
Strukturkomponenten an und geben Sie diese anschließend nochmals auf dem Bildschirm aus.
Erweitern Sie das Programm um eine Funktion Eingabe und Ausgabe welche als Parameter
die Struktur erhalten.
#include <iostream>
#include <conio.h>
//Deklaration der Struktur

struct auszugstruktur{
char name[30];
unsigned long kontonummer;
float kontostand;
};
void eingabe(auszugstruktur &);
void ausgabe(const auszugstruktur &);
void main()
{
//Anlegen einer Variablen
auszugstruktur kontoauszug;
eingabe(kontoauszug);
ausgabe(kontoauszug);
}
void eingabe(auszugstruktur & kontoauszug)
{
//Einlesen von Werten
cout<<"Bitte Name eingebn :";
gets(kontoauszug.name);
cout<<"Bitte Kontonummer eingeben :";
cin>>kontoauszug.kontonummer;
cout<<"Bitte Konstostand eingeben :";
98
01.09.2003
cin>>kontoauszug.kontostand;
void ausgabe(const auszugstruktur & kontoauszug)

{
//Ausgabe der Strukturkomponenten
cout<<endl<<"Name : "<<kontoauszug.name;
cout<<endl<<"Kontonummer : "<<kontoauszug.kontonummer;
cout<<endl<<"Kontostand : "<<kontoauszug.kontostand;
cout<<endl;
}
Der Eigene Datentyp einer Struktur lässt sich im Programm genauso verwenden wie die
einfachen Datentypen (int double usw.). Der Unterschied zu den einfachen Datentypen
Besteht darin das keine Operatoren zur verfügung stehen.
Aufgabe:
Definieren Sie eine Struktur welche als Strukturkomponenten den Real und den imaginärteil
einer Komplexen Zahl erhält. Schreiben Sie eine Funktion zur ein und ausgabe und zur
Addition und Subtraktion von zwei Komplexen Zahlen.
Speichern von Daten auf einem externen Datenträger

1. Dekleration der Dateivariablen (FILE* dat;)
2. Öffnen der Datei in einem Modus und zuweisung an die Dateivariable
dat=fopen(„Pfad“,“Modus“);
z.B. dat=fopen(„H:\\test.dat“,“wb“);
Hinweis:
- Pfad nach DOS- Konvention
- Zwei Backslash verwenden (ESC- Sequenz)
Modus:
- „wb“ – zum Schreiben
- „rb“ – zum Lesen
- „ab“ – zum Anhängen
Befehle zum Schreiben/ Lesen:

3. fwrite( &Variable, sizeof(Variable),1,Dateivariable);
&Variable: Adresse der Variablen welche geschrieben werden soll
sizeof(Variable): Anzahl der Bytes
1: Anzahl wie oft die Anzahl der Bytes gelesen weden soll
Dateivariable: Ist die Variable welche mit der Datei verbunden ist in die geschrieben
werden soll
fread(&Variable,sizeof(Variable),1,Dateivariable); Bedeutung siehe oben.
Datei schließen
4. fclose(&Variable,sizeof(Variable),1,dat);
99
01.09.2003
schließt die Dateivariable die mit der Datei verknüpft ist

Hinweis:
- Die Variablen und Funktionen zur Dateiarbeit befinden sich ind der Bibliothek
<cstdio>
Aufgabe:
Schreiben Sie ein Programm welches eine Integer Variable Zahl, mit dem Wert 65 in eine
Datei schreibt. Und anschließend den wert aus der Datei in eine Variable Test einließt und auf
dem Bildschirm ausgibt.
Fehlerabfrage beim öffnen der Datei:
Konnte die Datei mit fopen nicht geöffnet werden so liefert fopen als Adresse NULL an den
Dateizeiger.
z.B.
if((dat=fopen(„H:\\test.dat“,“rb“))= =NULL)
{
cout<<”Fehler!!!”;
getch();
exit(0);
}
else{
fread.....
fread….
}
Umgang mit ASCII Dateien:

Möchte man ASCII Dateien auf dem Bildschirm anzeigen bzw. in diese schreiben so kann
man dies zeichenweise mit hilfe einer char Variablen realisieren. Wird die fread Anweisung
im Kopf einer while Schleife genutzt, denn fread liefert eine NULL wenn das Dateiende
erreicht ist.
Aufgabe:
Schreiben Sie ein Programm welches sich selbst Zeichenweise auf dem Bildschirm ausgibt.
#include <iostream>
#include <cstdio>
#include <conio.h>
void main()
{
cout<<"Lesen einer ASCII Datei"<<endl;
char ch;
FILE*dat;
if((dat=fopen("H:\\programmierung\\dateiarbeit\\bildschirm\\aufgabe2.cpp","rb"))==NULL)
100
01.09.2003
{
cout<<"Fehler!!!";
getch();
exit(0);
}
else{
while(fread(&ch,1,1,dat)){
cout<<ch;
}
fclose(dat);
}
}
Aufgabe:
Schreiben Sie einen einfachen Editor mit welchem sie Zeichen in eine Datei schreiben
können. Überlegen Sie sich dabei eine sinnfolle endekennung. Geben Sie anschließend den
Text nochmals auf dem Bildschirm aus.
#include <iostream>
#include <cstdio>
#include <conio.h>
void main()
{
cout<<"Schreiben einer ASCII Datei"<<endl;
char ch;
FILE*dat;
if((dat=fopen("H:\\programmierung\\dateiarbeit\\bildschirm\\test\\test.txt","wb"))==NULL)
{
cout<<"Fehler!!!";
getch();
exit(0);
}
else{
while((ch=getche())!= 27){
fwrite(&ch,1,1,dat);
if(ch==13){
ch=10;
cout<<ch;
fwrite(&ch,1,1,dat);
}
}
fclose(dat);
}
cout<<endl<<endl;
if((dat=fopen("H:\\programmierung\\dateiarbeit\\bildschirm\\test\\test.txt","rb"))==NULL)
{
cout<<"Fehler!!!";
101
01.09.2003
getch();
exit(0);
}
else{
while(fread(&ch,1,1,dat)){
cout<<ch;
}
fclose(dat);
}
}
Aufgabe:
Füllen Sie ein Feld mit 100 Zufallszahlen zw 1-100. Schreiben Sie anschließend in eine Datei.
Versuchen Sie das Feld in eine andere Feldvariable zu lesen.
Aufbau einer Dateiverwaltung

Eine Datenverwaltung zum Thema Telefonverzeichnis ist zu erstellen.
Aufbau der Struktur: sei Name Vorname jeweils 30 Zeichen. Telefonnummer 20 Zeichen. In
einem Menü sind die Punkte:
1. Eingabe/ Speichern
2. Ausgabe aller Daten
3. Suchen
4. Löschen
5. ESC zum Beenden
Anzubieten.
Schreiben sie zu den Menüpunkten die Funktionen:
Eingabe
Ausgabe
Suchen
Löschen
Funktion Eingabe:
1. Dekleration der Variablen vom Typ Ttel Dateivariable vom Typ FILE *
2. Eingabeaufforderung und einlesen der Strkturkomponeneten
3. Öffnen der Datei Ttel.dat im Modus AB
4. Schreiben der Strukturvariablen mit fwrite
5. Schließen der Datei
Funktion Ausgabe:
1. Variable vom Typ Ttel und FILE * anlegen
2. Datei öffnen im Modus RB
3. solange die Daten mit fread gelesen werden können ausgabe der Daten
Funktion Suchen
1. Variablen vom Typ Ttel und FILE * und char 30 (für den Suchbegriff)
2. Suchname einlesen
102
01.09.2003
3. Datei öffnen im Modus rb

4. solange Daten mit fread gelesen werden können wenn Suchname = Name dann
ausgabe des Datensatzes
Funktion Löschen
1. Variablen vom Typ Ttel und FILE* und Variable für den Suchnamen
2. Suchname einlesen
3. Datei im Modus rb öffnen datei Hilf.dat im Modus wb öffnen
4. solange man mit fread Daten lesen kann vergleicht man wenn Suchname und name
verschieden, schreiben des Datensatzes mit fwrite in die Hilfsdatei
5. schließen der Datei
6. löschen von der der originaldatei remove(„Pfad zur Datei“);
7. umbenennen von Hilf.dat in Tel.dat rename („Altername“,“Neuername“);
Aufgabe:
Schreiben sie eine Funktion ändern welche es ermöglicht einen Datensatz zu ändern.
Organisation und Implementierung von Header- Dateien

Eingroßes Programm in einer einzigen Datei zu verwalten ist schwierig.
Nachteile:
lange Übersetzungszeiten
unübersichtliche Anordnungen
Probleme bei mehreren Personen, welche in einem Programm arbeiten
Lösung:
Man trennt Programme daher meist in mehrere Dateien auf die auch getrennt von einander
Compiliert und getestet werden können.
Aufspaltung in Implementierungsdateien (Quelltextdateien) und in Headerdateien welche nur
die Deklarationen von Funktionen und Variablen enthalten.
Dateiendung.h
Header
1. include- guards (um mehrfaches einschließen von Headerdateien zu verhindern)
#ifndef Name.h
#define Name.h
//Deklarationen
#endif
2. Deklaration von Funktionen
3. Definition von Inline Funktionen
4. Deklaration von Klassen und dessen Elementfunktionen
5. Deklaration von globalen Variablen extern
103
01.09.2003
Header
//Name.h
#idndef _Name_
#define _Name_
......Deklarationen........
#endif
//Name.cpp
//Definitionen
#include „Name.h“
//Quelltext
Zeiger
Ein Zeiger ist ein Datentyp dessen Variable eine Adresse als Argument erwartet.
Ohne Adresse ist ein Zeiger nutzlos.
Deklaration von Ziegervariablen
<Datentyp> *<Bezeichner der Zeigervariablen>;
Datentyp gibt den Typ der Variablen an dessen Adresse die Zeigervariable aufnehmen soll.
z.B.
int *zeiger; //Zeigervariable, welche die Adresse von Integervariblen aufnehmen kann
Zuweisung einer Adresse
Die Zuweisung einer Adresse an die Zeigervariable erfolgt mit Hilfe des & Adressoperators.
z.B.
zeiger=&intzahl; //Zeiger erhält Adressen von intzahl
Man beachte, den Stern vor der Zeigervariablen muß man weglassen!
104
01.09.2003
Zugriff auf den Inhalt der Adresse,
welcher der Zeigervariablen zugewiesen wurden erfolgt mit dem Stern vor dem Bezeichner.
z.B.
*zeiger=123; //weist die Adresse auf welche Zeiger zeigt den Wert 123 zu * als
//Inhaltsoperator
Skizze
int zahl
int *zeiger;
FF00 123 zahl
FF04 FF00 zeiger
Zeiger=&zahl
*zeiger=123
Schreiben Sie ein Beispielprogramm in welchem Sie eine Varible und einen Zeiger anlegen
vom gleichen Typ. Anschließend dem Zeiger die Adresse der Variablen zuweisen. Über den
Zeiger den Wert der Variablen verändern und auf dem Bildschirm die Adresse der Variablen
und Inhalte ausgeben.
Anwendung zu Zeigern
• Zur Übergabe von Argumenten an Funktionen, wenn die Funktion diese Argumente
verändern soll. (Call by Referenz)
• Für den zugriff auf die Elemente eines Vektors
• Zur Übergabe von Vektoren und Zeichenketten an Funktionen
• Bei der Speicherplatzanforderung an das System
• Um Datenstrukturen wie verkettete Listen zu erezeugen
105
01.09.2003
Übergabe von Argumenten an Funktionen( Call by Referenz)

Prototyp:
void tausch (int *z1, int *z2); //Argumente sind Zeiger vom Typ der Variablen, welche
//übergeben werden sollen
Aufruf:
tausch(&a, &b); //Übergabe der Adressen von a und b
Definition:
void tausch(int *z1, int *z2) //Argumente müssen Zeiger sein
{ //z1 und z2 zeigen auf die gleiche Adresse
int hilf; //wie a und b
hilf= *z1;
*z1= *z2;
*z2= hilf;
}
Anwendung von Zeigern

Zeiger auf Felder
Man beachte der Datentyp der Feldelemente muß mit dem Datentyp des Zeigers
übereinstimmen.
z.B.
int intfeld[10]; //Integerfeld
int *zeiger; //Zeiger vom Typ int
Zuweisung der Anfngsadresse des Feldes
Erfolgt in der Regel durch den Bezeichner des Feldes oder auch möglich durch die Zuweisung
der Adresse des ersten Feldelementes.
z.B.
zeiger= intfeld; //üblich
oder zeiger=& intfeld[10]; //unüblich
Zugriff auf den Inhalt der Adresse bzw. auf die Feldelemente
Erfolgt über den Inhaltsoperator *(Derefernezoperator) und die Nutzung der Zeigerarithmetik.
z.B.
1.Möglichkeit:
for(int i=0; i<10; i++)

*(zeiger+i)= rand()%100+1 //Füllt das Feld mit Zufallszahlen von 1-100
106
01.09.2003
2.Möglichkeit:
for(int i=0; i<10; i++)

*zeiger++= rand()%100+1 //Füllt das Feld mit Zufallszahlen von 1-100
//zuerst wird der Inhaltsoperator ausgeführt und anschließend
//Postfix ++
Zeigerarithmetik:
Erhöht sich der Wert einer Adresse um 1 sorgt die Zeigerarithmetik dafür das sich der Wet
der Adresse um 1mal dem des Speicheraufwand des Datentyps erhöht z.B. ein float Zeiger
erhöht bei einer Addition um 1 den Wert der Adresse um 4.
Aufgabe:
Testen Sie beide Zugriffsmöglichkeiten in dem Sie Möglichkeit 1 das Feld mit Zufallszahlen
und mit Möglichkeit 2 das Feld ausgeben.
Aufgabe:
Schreiben Sie ein Programm in Welchem Sie ein Integerfeld mit 20 Zufallszahlen von 1-100
füllen und stellen Sie anschließend in einer Funktion über Zeiger fest wie viele Zahlen <= 50
bzw. >50 waren.
void fuenfzig(int *zei, int anz)

{
int klgl=0, gr=0;
for(int i=0; i<anz ;i++){
if(*(zeiti)<=50){
klgl++;
}
else{
gr++;
}
}
cout<<“Größer“<<gr<<“Kleiner: „<<klgl;
}
107
01.09.2003
Zeiger auf Zeichenketten
Zeiger auf Zeichenkettenkonstanten
z.B.
D Str1 D
E E
F Str2 F
V V
E E
K K
\0 \0
char Str1[]=”DEF.VEK.” char *Str2=”DEF.ZEI.”
Der Unterschied zwischen Str1 und Str2 ist, dass Str1 eine Adresse (daher eine
Zeigerkonstante) und Str2 eine Zeigervariale ist. Str2 kann verändert werden aber Str1 nicht.
z.B.
Str1++ ; //geht nicht

Str2++; //geht
Betrachte: Eine Zeichenkette, die als Zeiger definiert wurde lässt sich flexibler verwenden.
Zeichenketten als Argumente von Funktionen

//Eine Zeichenkette in Zeigerschreibweise darstellen
//Prototyp
void zeige_kette(char *);
void main()
{
char str[]=“Wer in der Schule sitzt, hat keine Freizeit mehr!“;
//Aufruf
zeige_kette(str);
}
//Definition der Funktion
void zeige_kette(char *zei)
{
while( *zei)
cout<<*zei++;
}
Aufgabe:
Schreiben und Testen Sie eine Funktion kopier( ), in welcher Sie mit Zeigern eine
Zeichenkette kopieren.
108
01.09.2003
Zusatz:
Schreiben Sie eine Funktion umkehr die Zeichenkette umgekehrt auf dem Bildschirm ausgibt.
Dynamische Speicherplatzanorderung an das System

C++ stellt noch einen anderen Weg zur Verfügung, um Speicherbereiche zu belegen:
Den: new- Operator
Dieser Operator fordert einen Speicherbereich beim Betriebssystem an und liefert als
Ergebnis einen Zeiger af die Anfangsadresse dieses Speicherbereiches.
Der Zugriff auf diesen dynamisch angeforderten Speicher erfolgt über den Zeiger.
z.B. float *zeiger; //deklarert einen Float- Zeiger
zeiger=new float; //erzeugt Adresse mit reservierten Speicherplatz für eine Float-Variable
*zeiger=123.456; //belegt Speicher mit inem Wert
Die Freigabe des mit new allozierten Speichers erfolgt mit dem delete- Operator.
delete zeiger;
Weitere Anwendungen:
Dynamisches Integerfeld erzeugen

1. Man fragt erst zur Laufzeit des Programms ab weviel Elemente benötigt werden.
int anz;
cout<<“Wie viele Daten? :“; cin>>anz;
if(anz<=0) exit(0);
2. Reservieren des notwendigen Speichers mit new und zuweisen der Adresse an einen
int zeiger.
int *pFeld= new int[anz];
3. Zugriff auf den reservierten Speicher erfolgt über den Zeiger und mit Hilfe der
Zeigerarithmetik.
Long t;
Srand(time(&t));
for(int i=0;i<anz; i++){
*(pFeld+I)= rand( )%100+1;
}
109
01.09.2003
Aufgabe:
Reservieren sie Dynamisch ein integer Feld und füllen Sie es mit Zufallszahlen zwischen 1
und 100. Geben Sie anschließend die Zufallszahlen auf dem Bildschirm aus.
#include <iomanip>
#include <iostream>
#include <ctime>
void main()
{
int anz;
cout<<"Wie viele Daten? :"; cin>>anz;
if(anz<=0) exit(0);
int *pFeld= new int[anz];
long t;
srand(time(&t));
for(int i=0;i<anz; i++){
*(pFeld+i)= rand( )%100+1;
}
for(i=0;i<anz;i++){
cout<<setw(4)<<*pFeld++;
}
Freigabe eines Feldes:

Delete[ ]pFeld;
Dialogbasierende Programme
Wichtige Funktionen für EditBox
Zeichenkette vom Typ Cstring aus der EditBox holen und in der Edit Variablen ablegen:
GetDlgItemText (ObjektID, EditVariable);
Umwandlung der EditVariablen in numerische Zielvariable:
ZielVariable= atof (EditVariable); //Typ double, float
110
01.09.2003
ZielVariable= atoi (EditVariable); //Typ int
Umwandlung der numerischen Zielvariablen in EditVariable:
EditVariable.Format („%Formatbezeichner“,Zielvariable);
Hinweis: Formatbezeichner analog nach printf( )
z.B. int %bd,%bi
float %b.nf
double%b.nlf
b: Breite der Ausgabe
n: Anzahl der Dezimalstellen (optional)
EditVariable vom Typ Cstring in EditBox
SetDLgItemText( objektID, EditVariable);
Wichtige Nachrichten für die EditBox:
Wo?: ObjektID z.B: IDC_Name
Was?: EN_KILLFOCUS
-wird aufgerufen wenn IDC_Name den Focus verliert
EN_SETFOCUS
-wird aufgerufen wenn IDC_Name den Focus erhält
Ausgabe von Fehlermeldungen:
MessageBox(„Dieser Text wird ausgegeben!“,“Title“);
Focus zurückgesetzen bzw. Zeiger auf ein Dialogelement setzen:
CWnd*pf= (CWnd*) GetDlgItem (ObjektID);

Pf->SetFocus( );
-erzeugt einen Zeiger auf ein Element des Dialogprogramms und wendet die Methode
SetFocus ( ) der Class CWnd an.
Dialogelemente aktivieren bzw. Deaktivieren
Zeiger auf das Element setzen:

CWnd * pf=(CWnd*) GetDlgItem(ObjektID);
z.B.
CWnd * pf= (CWnd*) GetDlgItem(IDC_Berechnen);
Methode zum Aktivieren und Deaktivieren

EnableWindow(Wahrheiswert) //True, False
pf->EnableWindow(False);
111
01.09.2003
Allgemeine Funktion zur Abfrage bzw. zum setzen von Inhalten

für Dialogelemente
Voraussetzung:
Mit Hilfe des Klassenassistenten wurden den Dialogelementen Variablen zugewiesen.
UpdateData(BOOL)
1. Möglichkeit
UpdateData(TRUE)
Liest alle Werte aus den Dialogelementen und weist sie den zugehörigen Variablen zu.
2. Möglichkeit
UpdateData(FALSE)
Schreibt die Werte der Variablen in die zugehörigen Dialogelemente.
Anwendung:
Taschenrechner
Aufgabe:
Realisieren sie einen Taschenrechner für die Grundrechenarten für double Zahlen. Verwenden
sie zum lesen und schreiben der Inhalte der Dialogelemente die Funktion UpdateData
Erstellung und Aufruf eines neuen Dialogfensters

1. Schritt: Erstellen eines neuen Dialogfenster
1.1 Ein Dialogfenster ist eine Ressource, mit Einfügen -> Ressource öffnen wir ein
Auswahlfenster, wählen dort Dialog und erhalten ein neues Dialogfenster, welches
man bearbeiten kann.
1.2 Ändern der IDD über Eigenschaften wie bekannt
1.3 Hinzufügen einer Klasse Cneu als Ableitung von Cdialog über Klassen- Assistenten
2. Schritt: Aufbau des neuen Dialogfensters mit entsprechenden Steuerelementen
3. Schritt: Aufruf des neuen Dialogfensters z.B. über einen Button
3.1. In den Ausgangsdialog wechseln und mit Hilfe des Klassen- Assistenten dem Button
ID_.... über BN_CLICKED eine neue Funktion hinzufügen
3.2. In der Funktion folgende Anweisungen hinzufügen
Cneu dlg; //Objekt von CNEu erstellen
Int erg=dlg.DoModal( ); //Ausführen des neuen Dialoges
If(erg= = IDOK) //Aktionen wen mit OK beenden

{
112
01.09.2003
//nur als Platzhalter hier könnte auch die Übergabe von Variablen stehen
MessageBox(„Dialog mit OK beendet!“,“Zur Information“);
}
if( erg= = IDCANEL) //Aktionen wenn mit Abbrechen beendet
{
//nur als Platzhalter gedacht
MessageBox(„Dialog mit Abbrechen beendet!“,“Zur Information“);
}
3.3. Einfügem der Anweisungen von #include „Neu.h“ in die Quelldatei damit die Klasse
Cneu bekannt ist.
Einfügen von Drehfeldern
1. Drehfeld aus der Toolbox einfügen

2. Spinbuttons sind immer int-Zähler
3.
m_dE.. = m_dE.. = 5.0 ;
CString help ;
help . Format ( "%2.1f" , m_dE…. ) ;
SetDlgItemText ( IDC_E_…. , help ) ;
SetDlgItemText ( IDC_E_…. , help ) ;
CSpinButtonCtrl * pSpin = ( CSpinButtonCtrl * ) GetDlgItem ( IDC_SPIN_…. ) ;

pSpin -> SetRange ( 10 , 100 ) ; pSpin -> SetPos ( 50 ) ;
pSpin = ( CSpinButtonCtrl * ) GetDlgItem ( IDC_SPIN_…. ) ;

pSpin -> SetRange ( 10 , 100 ) ; pSpin -> SetPos ( 50 ) ;
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX-Eigenschaftenseiten sollten FALSE zurückgeben
113

C++ Programmierung 1 Jahr

Hochgeladen von

Dokumentinformationen

Originaltitel

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

C++ Programmierung 1 Jahr

Hochgeladen von

Copyright:

Verfügbare Formate

01.09.

Erstellen eines C Programms

Dienstprogramme: - Editor (Quelltext des Programms schreiben (Quellcode) )

- Compiler (übersetzen des Quelltextes in eine Maschinen nahe Form)

- Linker (dem Programm werden notwendige Funktionen hinzugefügt und

Konsolenanwendung in der IDE erstellen

Arbeitsbereich und ein Projekt anlegen

- Menübefehl Datei/ Neu aufrufen

Auswählen der Option EIN Leeres Projekt

Aufnehmen einer Quelltextdatei in das Projekt

- Menübefehl PROJEKT / DEM PROJEKT HINZUFÜGEN / NEU aufrufen

Quelltext eingeben und Datei speichern

Programm erstellen lassen

- Menübefehle ERSTELLEN / Name.exe erstellen

Programm ausführen lassen

Befehl ERSTELLEN / AUSFÜHREN VON Name.exe

Eigenschaften von C++

Umwandlung Dezimalzahl in Dualzahl

Bilden einer negativen Dualzahl

Man bildet die Dualzahl des Betrages der negativen Dezimalzahl

1ner Kompliment bilden.

Grundgerüst eines C++ Programms

#include <iostream> // einbinden der Bibliotheken

using namespace std;

cout <<“Hallo Visual C++!!!!“; // Anweisung zur Textausgabe

Allgemeines zu Programmen in C++

Syntax der Kommentare

// Dies ist ein Kommentar

Variablen und Konstanten

Typ Speicheraufwand in Bit Wertebereich

Typ Genau Bit Wertebereich

Initialisierung von Variablen

z.B. int zahl =12; //zahl erhält Anfangswert 12

z.B. const double PI= 3.14259265 ;

Eine Ausnahme bildet der Modulo Operator.

Vorrangregeln sind wie in der Mathematik Punktrechnung vor Strichrechnung.

Berechnung von Ausdrücken

größer als >

Verg.1 Verg.2 UND

Verg.1 Verg.2 ODER

Ausgabe mit cout

Eingabe mit cin

z. B. cin>>Test; //Test erhält Wert der Eingabe

Ablauf: Überschrift: Ausgabe ganzer Zahlen

Daten (Variablen Konstanten):

Variable: Radius, Umfang, Flächeninhalt double

const double PI=3.141592654;

z.B. Addition: z1+z2

Die folgenden Anweisungsform ist üblich:

Es gibt für alle arithmetischen Operatoren einen entsprechenden arithmetischen

z.B. test /= 3; //entspricht test = test /

Rang Operator Bedeutung, Verwendung

Was gibt folgendes Programm aus?

Was gibt folgendes Programm aus?

Welchen wert haben die Ausdrücke?

Int x = 2, y = 5, z = 7 ; float z1 = 1.3 ;

a.) ( x < 5 ) && ( z > y ) 1

b.) ( y <= x) || !( y < 4 ) 1

c.) ( x != 0 ) && ( z >= y ) 1

Manipulatoren zur Formatierung von Ganzzahlen

showpos Positiven Zahlen werden mit Vorzeichen ausgegeben

Manipulatoren zur Formatierung von Gleitpunkzahlen

fixed Darstellung als Festpunktzahl