PDF Archive

Easily share your PDF documents with your contacts, on the Web and Social Networks.

Share a file Manage my documents Convert Recover PDF Search Help Contact



GrundlagenC++ .pdf



Original filename: GrundlagenC++.pdf

This PDF 1.2 document has been generated by / Acrobat Distiller 4.0 for Windows, and has been sent on pdf-archive.com on 30/06/2013 at 08:27, from IP address 95.90.x.x. The current document download page has been viewed 1187 times.
File size: 321 KB (68 pages).
Privacy: public file




Download original PDF file









Document preview


Grundlagen der Programmierung in C++

datadidact

Bestellnummer 98067
Verlag für Bildungsmedien im Datenverarbeitungsunterricht
An den Tongruben 29
76764 Rheinzabern
Information und pädagogische Beratung: Tel: (0 72 72) 77 48 77
Fax: (0 72 72) 77 48 78
Druckzentrum und Verkauf:

Tel: (07 21) 9 20 47 32
Fax: (07 21) 9 20 47 16
EMail: info@kopierstelle.com

C++ Programmierung

1 Grundlagen der Programmierung in C++

Inhaltsverzeichnis
1.1
Wie erstelle ich eigene Software?
3
PROGRAMMIERSPRACHEN ....................................................................................................................................................................3
GRUNDLAGEN DES PROGRAMMIERENS.................................................................................................................................................5
DER BEGRIFF “ALGORITHMUS”...........................................................................................................................................................6
BESCHREIBUNGSMÖGLICHKEITEN FÜR ALGORITHMEN .........................................................................................................................7
1.2
Aufbau eines Programmes in C++
9
VOM QUELLTEXT ZUM LAUFFÄHIGEN PROGRAMM ...............................................................................................................................9
PROGRAMMAUFBAU ..........................................................................................................................................................................10
KOMMENTARE ...................................................................................................................................................................................11
DATENTYPEN .....................................................................................................................................................................................11
VARIABLEN .......................................................................................................................................................................................12
KONSTANTEN.....................................................................................................................................................................................12
ANWEISUNGEN ..................................................................................................................................................................................13
WERTZUWEISUNG, RECHENOPERATIONEN .........................................................................................................................................14
IMPLIZITE UND EXPLIZITE TYPKONVERTIERUNG .................................................................................................................................15
INKREMENT- UND DEKREMENTOPERATOREN .....................................................................................................................................15
1.3
Folge (Sequenz)
17
DARSTELLUNG DER FOLGE IM STRUKTOGRAMM ................................................................................................................................17
BENUTZERFREUNDLICHKEIT ..............................................................................................................................................................17
ANFANGSPROBLEME UND DEREN LÖSUNGEN .....................................................................................................................................20
1.4
Auswahl (Selektion)
22
EINSEITIGE AUSWAHL........................................................................................................................................................................22
LOGISCHE VERGLEICHSOPERATOREN .................................................................................................................................................23
PROBLEME UND DEREN LÖSUNG BEI EINSEITIGER AUSWAHL..............................................................................................................25
ZWEISEITIGE AUSWAHL .....................................................................................................................................................................26
MEHRSEITIGE AUSWAHL....................................................................................................................................................................29
PROBLEME UND DEREN LÖSUNG BEI ZWEI- UND MEHRSEITIGER AUSWAHL ........................................................................................33
1.5
Wiederholung (Repetition)
34
SCHLEIFE MIT ENDABFRAGE ..............................................................................................................................................................35
PROBLEME UND DEREN LÖSUNG ........................................................................................................................................................37
SCHLEIFE MIT ANFANGSABFRAGE ......................................................................................................................................................38
PROBLEME UND DEREN LÖSUNGEN ....................................................................................................................................................41
DIE ZÄHLSCHLEIFE ............................................................................................................................................................................42
ZÄHLSCHLEIFE MIT VARIABLER SCHRITTWEITE ..................................................................................................................................43
ZÄHLSCHLEIFE MIT LOKAL DEKLARIERTER LAUFVARIABLE ................................................................................................................44
ANWEISUNGEN FÜR SCHLEIFENABBRUCH UND -WIEDERHOLUNG .......................................................................................................48
1.6
Modul (Unterprogramm, Funktion)
49
FUNKTIONEN OHNE PARAMETER ........................................................................................................................................................51
FUNKTIONEN MIT WERTEPARAMETERN..............................................................................................................................................53
FUNKTIONEN MIT REFERENZPARAMETERN .........................................................................................................................................54
FUNKTIONEN MIT RÜCKGABETYP.......................................................................................................................................................56
VERSCHACHTELTER FUNKTIONSAUFRUF ............................................................................................................................................59
1.7
Sprachspezifische Besonderheiten bei Funktionen
60
GÜLTIGKEITSBEREICH UND SICHTBARKEIT VON BEZEICHNERN ..........................................................................................................60
FUNKTIONSDEFINITION UND FUNKTIONSDEKLARATION ......................................................................................................................61
INLINE-FUNKTIONEN ..........................................................................................................................................................................62
INITIALISIERUNG VON LOKALEN VARIABLEN, STATISCHE LOKALE VARIABLEN ..................................................................................62
KONSTANTE WERT- UND REFERENZPARAMETER ...............................................................................................................................63
REFERENZ AUF DEN FUNKTIONSNAMEN .............................................................................................................................................64
ÜBERLADENE FUNKTIONSNAMEN ......................................................................................................................................................65
DEFAULT-ARGUMENTE ......................................................................................................................................................................66
SCHABLONEN (TEMPLATES) FÜR FUNKTIONEN...................................................................................................................................68

Programmieren mit C++

datadidact
1-2

2000-06

1 Grundlagen der Programmierung in C++

1

C++ Programmierung

Grundlagen der Programmierung in C++

C++ ist eine moderne Programmiersprache, an deren Beispiel sich grundsätzliche Eigenschaften und
Vorgehensweisen anderer Programmiersprachen erlernen lassen. Die Codierung der Algorithmen kann daher
sinnvoll in C++ erfolgen. Das Hauptaugenmerk soll aber hauptsächlich auf der Herleitung der Algorithmen
liegen, nicht auf der Verwendung einer speziellen Programmiersprache.

1.1 Wie erstelle ich eigene Software?
Um spezielle Problemlösungen zu erstellen bzw. Unterstützung durch den Computer zu erfahren, bedient sich
der Anwender spezifischer Softwareprogramme, die im Falle der Nutzung von DOS-kompatiblen Rechnern in
großer Fülle auf dem Markt angeboten werden. Hier sind oft Programme notwendig, die auf die eventuell
erforderlichen Bedürfnisse des Benutzers zugeschnitten werden. Man spricht in diesem Fall von
Programmanpassungen über die Programmier- bzw. Softwareschnittstelle. Bei Computersystemen in höheren
Größenordnungen wird die Software für den Benutzer auf der Basis des dort bestehenden Betriebssystems
speziell geschrieben, so dass den betrieblichen Anforderungen schon von Anbeginn Rechnung getragen wird.
Man kann Software also auch unterscheiden in fertiggestellte Programme und in Programmiersprachen, mit
denen sie erstellt werden können.

Lerninhalte

L1

!
"
#
$

Programmiersprachen
Grundlagen des Programmierens
Der Begriff “Algorithmus”

Lerninhalte

Beschreibungsmöglichkeiten für Algorithmen

Programmiersprachen

Programme, die für einen Computer geschrieben werden, bedienen sich des Befehlsvorrats, den der Mikroprozessor im Computer „verstehen“ kann. Der Prozessor vom Typ 8080 z. B. versteht 243 verschiedene
Befehle wie „addiere“, „subtrahiere“, „hole aus Speicherzelle“ usw. Diese Befehle werden dem Prozessor
allerdings in binär codierter Form eingegeben. Der Befehl „addiere“ lautet beispielsweise verschlüsselt
10000110. Da diese Verschlüsselung oder „Sprache“ den Prozessor direkt zur Ausführung von Operationen
veranlasst, nennt man sie auch Maschinensprache.
Allerdings ist diese Form der Sprache zum Programmieren sehr ungünstig; man müsste in diesem Fall nämlich
243 verschiedene 8-stellige Zahlen kennen und die entsprechende Funktion zuordnen. Es lag nahe, anstelle der
Zahlenkombination Abkürzungen zu verwenden, die von ihrer Namensgebung einen Rückschluss auf die
Funktion zulassen (sogenannte Mnemonics). Aus dem Zahlencode wurde ein Buchstabencode und die
Umsetzung übernimmt ein entsprechendes Programm, der sogenannte Assembler. ADD z. B. steht für addiere,
SUB steht für subtrahiere. Diese Beschreibungsart nennt man Assemblersprache.
Die Assemblersprache ist sehr maschinennah, aber immer noch bedienerunfreundlich. Insbesondere weist
jeder Mikroprozessortyp eine andere Assemblersprache auf. Die Folge davon war die Entwicklung von
höheren Programmiersprachen. Diese beinhalten nun Wörter aus der (englischen bzw. amerikanischen) Umgangssprache, so dass der Abstraktionsgrad nicht mehr so hoch und die Eingabe von Befehlen wesentlich komfortabler ist. Nach Abschluss einer Programmerstellung muss dieses lediglich mit einem Übersetzungsprogramm (Compiler oder Interpreter) in die jeweilige Maschinensprache übertragen werden, damit die Befehlsmenge für den Prozessor „verständlich“ ist und dieser sie ausführen kann. Damit ist auch gewährleistet,
dass die gleichen Programme auf verschiedenen Mikroprozessorsystemen abgearbeitet werden können.
Wichtige Hochsprachen sind im folgenden kurz genannt.
1. FORTRAN (Formula Translator, entstanden 1954)
2000-06
Programmieren mit C++
datadidact
1-3

C++ Programmierung

1 Grundlagen der Programmierung in C++

ist die meistverbreitete Hochsprache zur Lösung mathematisch-naturwissenschaftlicher Probleme. Die
Sprache entspricht nicht mehr den modernen Erkenntnissen der strukturierten Programmierung, dennoch
wird sie wegen der großen Menge geschriebener Software noch lange verwendet werden.
2. COBOL (Common Business Oriented Language entstanden 1959)
ist die verbreitetste Programmiersprache für kommerzielle Problemstellungen. Bezüglich Sprachsyntax und
Menge der programmierten Software gilt ähnliches wie bei FORTRAN.
3. ALGOL (Algorithmic Language, entstanden etwa 1960)
war eine Spezialsprache für mathematisch-wissenschaftliche Probleme. ALGOL wird in der heutigen
Programmentwicklung nicht mehr praktisch verwendet. Die knappe, einheitliche und geschlossene
Sprachdefinition diente jedoch als Vorbild für die moderneren strukturierten Hochsprachen.
4. BASIC (Beginners All Purpose Symbolic Instruction Code)
ist auf Mikrocomputern mit am weitesten verbreitet. Die stärkste Syntax-Verwandtschaft besteht zu
FORTRAN. BASIC ist jedoch wenig standardisiert und ursprünglich unstrukturiert. Nach dem Aufkommen
von PASCAL erschienen immer mehr BASIC-Dialekte, die auch eine Unterstützung der strukturierten
Programmierung aufweisen.
5. PASCAL (benannt nach Blaise Pascal, einem Wissenschaftler des 17. Jahrhunderts, entstanden 1972)
Die Sprache ist an ALGOL angelehnt, wurde unter didaktischen Gesichtspunkten entwickelt und zwingt zu
strukturierter Programmierung, daher wird sie zu Lehrzwecken sehr gerne eingesetzt. Im Bereich der
kommerziellen Programmierung hat sie nicht viel Anklang gefunden.
Die Implementation TURBO-PASCAL bzw. BORLAND-PASCAL ist auf IBM-kompatiblen Rechnern zu
einem Quasi-Standard geworden. In der grafischen Variante zur Windows-Programmierung ist ein
PASCAL-orientiertes Entwicklungssystem unter dem Namen DELPHI bekannt.
6. C (entwickelt aus der Sprache „B“, etwa 1969), C++ (ab 1979)
C ist die in der professionellen Softwareentwicklung am häufigsten verwendete Sprache. Obwohl
ursprünglich für die Systemprogrammierung entworfen, lassen sich mit ihr auch gut strukturierte
Programme für beliebige Anwendungsbereiche entwickeln. Die Spracherweiterung C++ ist mittlerweile der
„Quasistandard“ in der professionellen Softwareentwicklung. Ihre Syntax dient als Grundlage für viele
neueren Programmiersprachen-Entwicklungen.
7. JAVA (ab 1994)
Die Sprache wurde zur herstellerunabhängigen Programmierung von Internet-Anwendungen entwickelt und
baut auf C++ auf.
8. ADA (benannt nach Lady Ada Augusta; veröffentlicht 1980)
wurde vom US-Verteidigungsministerium als Universalsprache für alle
Programmentwicklungen
herausgebracht. Sie ist daher streng standardisiert und unterstützt parallel ablaufende Prozesse, hat sich
jedoch in der professionellen Softwareentwicklung nicht stark verbreitet.
9. MODULA 2 (entstanden 1976) und OBERON
MODULA 2 wurde von PASCAL-Erfinder Niklaus Wirth, Professor an der Eidgenössischen Technischen
Hochschule in Zürich als Nachfolgesprachen von PASCAL entwickelt. Sie ist besser strukturiert und
unterstützt modulares Programmieren. Als objektorientierte Nachfolgesprache entwickelten Wirth und
seine Mitarbeiter die Sprache OBERON.

Programmieren mit C++

datadidact
1-4

2000-06

1 Grundlagen der Programmierung in C++

C++ Programmierung

10.Weitere Hochsprachen sind z.B. LISP und PROLOG für Anwendungen der sogenannten Künstlichen
Intelligenz, PL/1 als Großrechner-Sprache, FORTH für Steuerungsanwendungen, LOGO als „kindgerechte
Programmiersprache“, ELAN, PEARL, PERL, SIMULA, APL usw.
Die bestehenden Sprachen werden ständig fortentwickelt, neue Konzepte fließen in die alten Sprachen mit ein,
wie z. B. die objektorientierte Programmierung.
Als kurzes Beispiel sollen in einer tabellarischen Übersicht die Befehle zur Bildschirmausgabe in
verschiedenen Hochsprachen dienen.
FORTRAN:
BASIC:
PASCAL:
MODULA-2:
C:
C++:

L2

FORMAT('Hallo Welt!')
PRINT "Hallo, Welt!"
WRITELN('Hallo, Welt!');
Write('Hallo, Welt!');WriteLn;
printf("Hallo, Welt!\n");
cout << "Hallo, Welt!" << endl;

Grundlagen des Programmierens

Die Praxis der Grundlagen der Programmierung wird in der Programmiersprache C++ behandelt. In C++ lässt
sich strukturiert programmieren, außerdem ist C++ weiter verbreitet als die klassischen Lehrsprachen Pascal
oder gar Modula-2. Die Grundlagen, die hier erarbeitet werden lassen sich mühelos auf andere Programmiersprachen anwenden. Auf viele Spezialitäten von C++, die sich in anderen Sprachen nicht wiederfinden, wird
im Grundlagenteil nicht eingegangen.
Alleine die Kenntnis der Befehle einer speziellen Hochsprache genügt nicht, um Programme erstellen zu können. Die Kodierung einer Vorschrift zur Problemlösung (Programmerstellung) steht vielmehr am Ende eines
länger dauernden Prozesses, der im folgenden skizziert ist.

Mensch

Problemstellung

Umgangssprache,
mehrdeutig, komplex
Struktursprache,
eindeutig, detailliert

Algorithmus
Assemblersprache

Hochsprache

Assembler

Compiler/Interpreter

Programmiersprache
eindeutiger Formalismus
genormt
prozessorunabhängig

Sprachenübersetzer
Maschinensprache,
prozessorabhängig

Maschinensprache
Maschine

Mikroprozessor

Von der Problemstellung bis zur Bearbeitung durch den Mikroprozessor

2000-06

datadidact
1-5

Programmieren mit C++

C++ Programmierung

1 Grundlagen der Programmierung in C++

Ausgangspunkt der Programmierung ist eine Problemstellung, die meist umgangssprachlich vorgegeben ist.
Daher ist sie oft mehrdeutig, unvollständig oder unklar; diese Mehrdeutigkeiten, Unvollständigkeiten und Unklarheiten müssen im Gespräch mit dem Problemsteller geklärt werden oder vom Programmierer in eigenem
Ermessen beseitigt werden.
Der erste Ansatz zur Lösung besteht darin, einen Algorithmus zur Lösung des Problems zu entwerfen, der
möglichst unabhängig von der verwendeten Programmiersprache ist. Dieser Entwurf wird zunächst grob sein
und muss verfeinert werden; dies kann in mehreren Stufen geschehen (Prinzip der schrittweisen
Verfeinerung). Ein wichtiger Ansatzpunkt für den Grobentwurf des Algorithmus' ist das EVA-Prinzip. Es ist
demnach wichtig zu erkennen, wo in der Problemstellung sich die Eingabedaten befinden, wo der
Verarbeitungsvorgang stattfindet und welches die interessanten Ausgabedaten sind (Problemanalyse).
Ist der Algorithmus fixiert, kann er in eine Programmiersprache übertragen werden. Dabei werden üblicherweise syntaktische Fehler gemacht (Schreibfehler), die sofort vom Compiler erkannt werden. Semantische
Fehler (auch logische Fehler genannt) sind Fehler in der Bedeutung; es wird etwas anderes programmiert, als
beabsichtigt. Diese Fehler sind schwer zu finden und müssen durch mehrfachen Test des Programms entdeckt
und eliminiert werden. Am Ende dieser Entwicklung steht ein Programm, welches das gestellte Problem
fehlerfrei löst.

L3

Der Begriff “Algorithmus”

Losgelöst von der gewählten höheren Programmiersprache muss zunächst eine genaue Beschreibung bzw. Definition des Problems, das gelöst werden soll, auf allgemeine Weise erreicht werden. Dazu bedarf es einer
exakten Analyse, die Aufschluss über einzugebende Daten und die Festlegung der auszugebenden Daten beinhaltet. Diese Analyse muss am Ende auch kleinste Schrittfolgen aufzeigen, die die Lösung der
Aufgabenstellung beschreiben.
Ein Algorithmus ist eine endliche Folge von eindeutig bestimmten, ausführbaren Anweisungen zur Lösung
einer Klasse von Problemen.
In einem Algorithmus werden also Anweisungen aneinandergereiht, die unser Problem lösen. Dabei sind
folgende Bedingungen zu beachten.
1. Die Anweisungsfolge muss ein Ende haben, sie muss terminieren. Ohne Ende liefert die Anweisungsfolge
nämlich kein Ergebnis.
2. Die einzelnen Anweisungen müssen eindeutig bestimmt und ausführbar sein. „Dividiere a durch b“
erscheint uns als sinnvolle Anweisung; im Falle b=0 ist diese Anweisung aber gar nicht mehr ausführbar,
und ein Computer reagiert auf solche Anweisungen dann mit Fehlermeldungen und Programmabbrüchen.
3. Die Anweisungsfolge löst eine Klasse von Problemen, also nicht nur das aktuelle Problem mit den
aktuellen Werten, sondern mindestens mit allgemeinen Werten oder sogar noch eine ähnliche
Problemstellung. Wenn z.B. das Ergebnis der Addition 4+5 gefragt ist, soll der Algorithmus a und b als
Eingabe nehmen und die Summe a+b ausgeben. Eventuell kann darüber nachgedacht werden, nicht nur die
Summe der Zahlen, sondern auch noch Differenz, Produkt und Quotient mit auszugeben.

Im täglichen Leben begegnen uns viele Dinge, die wir unbewusst mehr oder weniger komplex ausführen und
Programmieren mit C++

datadidact
1-6

2000-06

1 Grundlagen der Programmierung in C++

C++ Programmierung

die sich, würden wir sie exakt beschreiben, als Alltagsalgorithmen darstellen.

Beispiel: Bedienung eines Getränkeautomaten
Umgangssprachlich: Ich werfe Geld hinein, er liefert mir mein Getränk
Eingaben in den Algorithmus:
Verarbeitung:

Ausgabe aus dem Algorithmus:
Eine Verfeinerung des Algorithmus ist möglich, indem man als weitere Eingabe die Geldmenge im Geldbeutel
betrachtet und nach dem Prüfen der Kosten testet, ob das Geld reicht. Nur in diesem Fall ist es nämlich
sinnvoll, Geld einzuwerfen.

L4

Beschreibungsmöglichkeiten für Algorithmen

Um einen Algorithmus letztlich in eine höhere Programmiersprache übertragen zu können, ist die rein verbale
Form wenig geeignet. Daher wird der Algorithmus zunächst graphisch dargestellt. Die graphische Form kann
dann in eine Pseudo-Programmiersprache oder in eine konkrete Programmiersprache übertragen werden.
Als graphische Darstellungsform werden der Programmablaufplan (PAP) und das Struktogramm verwendet.
Programmablaufplan (PAP).
Der PAP leitet nicht zum strukturierten Programmieren an, daher wird er nicht näher besprochen.

2000-06

datadidact
1-7

Programmieren mit C++

C++ Programmierung

1 Grundlagen der Programmierung in C++

Ausschnitt aus einem Programmablaufplan
Struktogramm
Struktogramme wurden 1973 von Nassi/Shneidermann entwickelt. Der Aufbau eines Struktogramms ist selbst
bei komplexen Algorithmen sehr übersichtlich, was ein einfaches Lesen zur Folge hat. Hinzu kommt, dass in
etwa zeitgleich die Programmiersprachen PASCAL und C entwickelt wurden, die die gleichen
Programmstrukturen verwenden. Ein Algorithmus, der mittels Struktogramm dargestellt wird, lässt sich
deshalb recht leicht in die Programmiersprachen PASCAL oder C übertragen.
Anhand eines Beispiels wird der Aufbau eines Struktogramms vorgestellt.
Problemstellung: Klassensprecherwahl mit zwei Kandidaten.
Auszählen der Stimmen bei der Klassensprecherwahl; Es gibt nur zwei Kandidaten; alle Stimmzettel befinden
sich in der Wahlurne und weisen einen der beiden Namen auf.

Struktogramm
Das gezeigte Struktogramm enthält die elementaren Grundstrukturen Folge, Auswahl und Schleife. Diese
Programmieren mit C++
2000-06
datadidact
1-8

1 Grundlagen der Programmierung in C++

C++ Programmierung

werden in einem der nächsten Abschnitte genauer erläutert.
Pseudo-Programmiersprache
Als Pseudo-Programmiersprache wird eine Sprache bezeichnet, die sich an eine bestehende
Programmiersprache anlehnt; bei der Formulierung des Algorithmus werden aber nicht so strenge Richtlinien
angelegt wie bei der konkreten Programmiersprache.
Beispiel:
ALGORITHMUS Klassensprecherwahl-Stimmauszaehlung
SOLANGE Stimmzettel in der Wahlurne TUE
BEGINN
Stimmzettel entnehmen
Stimmzettel lesen
WENN Name = A-Mann DANN Strich bei A-Mann
SONST Strich bei B-Frau
ENDE
Striche zaehlen
WENN Anzahl der Striche A-Mann = Anzahl der Striche B-Frau
DANN Losentscheid
SONST
WENN Anzahl Striche A-Mann > Anzahl Striche B-Frau
DANN A-Mann gewaehlt
SONST B-Frau gewaehlt

1.2 Aufbau eines Programms in C++

Lerninhalte

L1

! Vom Quelltext zum lauffähigen Programm
" Programmaufbau
# Kommentare
$ Datentypen
%& Variablen
' Konstanten
( Anweisungen
) Wertzuweisung, Rechenoperationen
* Implizite und explizite Typkonvertierung
+ Inkrement- und Dekrementoperatoren

Lerninhalte

Vom Quelltext zum lauffähigen Programm

Wir arbeiten mit der integrierten Entwicklungsumgebung von Borland C++ unter Windows. Weltweit
existieren ca. 10 Entwicklungssysteme für C++. Seit dem Jahr 1998 ist die Sprache nach ISO standardisiert, so
dass alle Programmbeispiele mit jedem C++-System ausgeführt werden können.
Im Entwicklungssystem werden die dem Menschen verständlichen C++-Quelltexte editiert (verändert), zudem
werden die jeweiligen Programme compiliert (übersetzt) und gelinkt (verknüpft, verbunden mit Bibliotheken).
Bei größeren Programmierprojekten arbeitet man immer mit mehreren CPP-Dateien – ihre Anzahl kann sehr
groß werden, wenn viele Programmierer an dem Projekt beteiligt sind. Der Compiler erzeugt aus den
Quelltexten *.CPP und *.H sogenannte Objektdateien (*.OBJ). Der Linker bindet diese Objektdateien mit
2000-06

datadidact
1-9

Programmieren mit C++

1 Grundlagen der Programmierung in C++

C++ Programmierung

Bibliotheksdateien (*.LIB) zu einem ablauffähigen EXE-Programm. Bibliotheksdateien enthalten vorgefertigte
Sammlungen von Programmmodulen.
ERSTPROG.CPP
main()

IOSTREAM.H

Compiler

X.CPP

Y.H

usw. ...

Compiler

Compiler

ERSTPROG.OBJ

X.OBJ

*.OBJ

*.LIB

Linker

ERSTPROG.EXE

L2

Programmaufbau

Das folgende Beispielprogramm in C++ hat die Struktur der Sequenz. Diese Struktur wird weiter unten
erläutert. Auch das EVA-Prinzip ist gut zu erkennen.
// Programm Erstprog.cpp
// Einbinden einer Header-Datei
// iostream.h ist notwendig, um Ein-/Ausgabe nutzen zu koennen
#include <iostream.h>
/* Definitionsteil */
// main() enthaelt das Hauptprogramm zwischen den geschweiften Klammern {}
void main()
{
// Deklaration der Variablen
float a,b,c;
/* Anweisungsteil */
// Startmeldung
cout << "Programm zum Addieren von zwei Zahlen." << endl;
// Eingabeaufforderungen
cout << "Geben Sie die erste Zahl ein: ";
cin >> a;
cout << "Geben Sie die zweite Zahl ein: ";
cin >> b;
// Berechnung der Summe, Ergebnis in c ablegen
c=a+b;
// Ergebnis ausgeben
cout << "Die Summe von " << a << " und " << b << " ist " << c << "."
<< endl;
}

An diesem Beispiel soll der Aufbau eines Programms in C++ erläutert werden.
Ein Programm in C++ besteht zunächst aus 2 Teilen.

Programmieren mit C++

datadidact
1-10

2000-06

1 Grundlagen der Programmierung in C++

C++ Programmierung

I.

Einbinden evtl. benötigter „Headerdateien“ (Vorspanndateien). Durch diese werden neue Befehle in
C++ zugänglich. Es gibt eine Reihe von Standard-Headerdateien, die bei jeder C++-Implementierung
mitgeliefert werden. Eine davon ist die Datei iostream.h, durch die Befehle zur Eingabe und
Ausgabe verfügbar werden.

II.

Im Definitionsteil werden benötigte Variablen und Funktionen definiert. Im hier dargestellten
einfachsten Fall wird nur die Funktion main() definiert, die das Hauptprogramm enthält. Funktionen
und damit auch das Hauptprogramm main bestehen wiederum aus zwei Teilen.
A.

Im Variablendeklarationsteil werden die benötigten Variablen und Konstanten eingeführt
(deklariert).

B.

Im Anweisungsteil wird der eigentliche Algorithmus in der Sprache C++ formuliert.

Grobanalyse des Beispielprogramms Erstprog.cpp
Im Deklarationsteil werden drei Variablen mit den Namen a, b und c deklariert. Diese können bestimmte
Datentypen („Datentypen“ siehe einen der nächsten Abschnitte) speichern, hier „float“, also
Fließkommazahlen.
Im Anweisungsteil werden verschiedene Anweisungen zur Ausgabe (cout <<) und Eingabe (cin >>) verwendet. Auch eine Berechnungsvorschrift (c=a+b) ist zu finden.

L3

Kommentare

Um den Überblick über ein größeres Programm zu behalten ist es wichtig, Programmteile optisch
voneinander trennen zu können und bestimmte Anmerkungen anbringen zu können. Dies geschieht durch
Kommentare, die vom restlichen Text auf zwei Arten abgetrennt werden können. Durch // wird ein
Kommentar eingeleitet, der bis zum Ende der Zeile geht. Kommentare können aber auch in /* ... */
eingeschlossen werden. Der Text in Kommentarklammern unterliegt keinen Einschränkungen und ist absolut
beliebig.

L4

Datentypen

C++ kennt verschiedene Datentypen, die jeweils einen bestimmten Platzbedarf und verschiedene
Wertebereiche haben.
Typname
Bereich
Platzbedarf in Bytes
Bool
true, false
1
Char
-128 bis 127 bzw. Zeichen nach ASCII-Tabelle, 1
z.B. ’A’ oder ’@’
unsigned char
0 bis 255 bzw. Zeichen nach ASCII-Tabelle, z.B. 1
’A’ oder ’@’
int
-32768 bis +32767
2
long
-2 147 483 648 bis +2 147 483 647
4
unsigned int
0 bis 65535
2
unsigned long
0 bis 4.294.967.295
4
float
4
±3,4*10-38 bis ±3,4*10+38
2000-06

datadidact
1-11

Programmieren mit C++

C++ Programmierung

1 Grundlagen der Programmierung in C++

±1,7*10-308 bis ±1,7*10+308
±3,4*10-4932 bis ±1,1*10+4932

double
long double

8
10

// Deklaration von Variablen
float a,a2;
// reelle Zahlen
char b;
// Zeichen
unsigned long l; // lange vorzeichenlose Ganzzahl
long double x;
// sehr genaue relle Zahl mit großem Zahlenbereich

Darüber hinaus können bei Bedarf weitere Typen definiert werden, z.B. Aufzählungstypen oder Verbunde.
// Definition neuer Typen
enum Wochentage {Mo,Di,Mi,Do,Fr,Sa,So}; // Aufzählungstyp
struct Datum { int Tag,Monat,Jahr } ;
// Verbund
// darauf aufbauende Deklaration von Variablen
Wochentage t; // Wert von Mo bis So
Datum d;
// Variable zusammengesetzt aus 3 Integer-Zahlen

L5

Variablen

In den Variablen eines Programms werden die zu verarbeitenden Daten, Ergebnisse und Zwischenergebnisse
gespeichert.
Variablen werden ebenso wie Typen über ihre symbolischen Namen angesprochen. Namen müssen mit einem
Buchstaben beginnen und dürfen ansonsten Buchstaben, Ziffern und den Unterstrich „_“ enthalten; Groß- und
Kleinschreibung wird beachtet, name, NaMe und NAME meinen also 3 verschiedene Variablen. Leerzeichen
können in Variablennamen nicht vorkommen.
Variablen können nur Daten eines bestimmten Datentyps speichern. Dieser Typ wird im Deklarationsteil festgelegt; er kann im Lauf des Programms nicht verändert werden.
Variablen bekommen einen Wert zugewiesen, indem man schreibt
Variablenname=Ausdruck;
a=1.2345; // Variable a erhält den Wert 1.2345
a2=a*5+7; // Variable a2 erhält den Wert, der sich aus der Formel berechnet
b=’z’;
// Variable b speichert das Zeichen ’z’

Konstante ASCII-Zeichen werden dabei in einfachen Apostrophen „’“ eingeschlossen. Bei reellen Zahlen
(float oder double) wird ein Dezimal-Punkt, kein Dezimal-Komma verwendet.

L6

Konstanten

Konstanten können wie Variablen angesprochen werden, verändern aber während des Programmlaufs ihren
Wert nicht. Wird dies trotzdem versucht, reagiert der Compiler mit einer Fehlermeldung. KonstantenBezeichner werden üblicherweise in BLOCKSCHRIFT deklariert.
Beispiele:

Programmieren mit C++

datadidact
1-12

2000-06

1 Grundlagen der Programmierung in C++

C++ Programmierung

const double PI=3.1415;
// Kreiszahl PI als double-Konstante
const float E=2.7172;
// Eulersche Zahl
const unsigned int ZWEIUNDVIERZIG=42; // ob das sinnvoll ist?

Zeichen und Zeichenketten (auch Literale genannt) werden in Apostrophen eingeschlossen. Einzelne Zeichen
werden dabei in einfachen Apostrophen „’“und Zeichenketten werden in doppelten Apostrophen „"“ eingeschlossen; letzteres wird häufig bei Ausgaben verwendet (cout << "Hallo"). Bei reellen float- oder
double-Zahlen wird ein Dezimal-Punkt, kein Dezimal-Komma verwendet.
Bestimmte ASCII-Zeichen sind nicht direkt ausgebbar; wie lasse ich z. B. den doppelten Apostrophen
ausgeben, wo der doch als Begrenzung für die auszugebende Zeichenkette dient? Deshalb werden diese
Zeichen über besondere sogenannte Escape-Sequenzen dargestellt, die alle mit dem Backslash „\“ beginnen:

Zeichen
\t
\v
\r
\n
\a
\b
\\
\’
\"
\xzz, \xZZ

L7

Bedeutung
Tabulator
Zeilensprung
Zeilenrücklauf
neue Zeile
Signalton
Backspace, löscht das Zeichen links von der Eingabemarke
der Backslash selbst
’ einfacher Apostroph
" doppelter Apostroph
Zeichen aus Sedezimalziffern, z.B. \x40 ist der ’@’

Anweisungen

Über Anweisungen wird der Ablauf des Programms gesteuert. Mit der Anweisung
cout << ... << ... ;

beispielsweise werden Zeichen, Zeichenketten und Zahlen auf dem Bildschirm ausgegeben. Mit
cin >> ... >> ... ;

werden Daten von der Tastatur in Variablen eingelesen.
Anweisungen werden immer mit einem Strichpunkt ; abgeschlossen. Mehrere Anweisungen werden mit den
geschweiften Klammern {...} zu einer Anweisungs-Gruppe zusammengefasst.
AnweisungA;
{ Anweisung1; Anweisung2; Anweisung3; }
AnweisungC;

Die Anweisungsgruppen werden bei den weiteren Strukturen benötigt; aber auch das Hauptprogramm main
besteht aus einer Anweisungsgruppe.
C++ stellt selbst bereits viele Anweisungen zur Verfügung. Eine besondere Art der Anweisung ist die Wertzuweisung, die meist mit der Ausführung von Rechenoperationen verbunden ist.
cout<< und cin>> sind genaugenommen keine Anweisungen, sondern Methodenaufrufe von Objekten, die durch überladene Operatoren << und >> realisiert sind.
Dabei soll das Objekt cout den Monitor repräsentieren, auf den die Daten ausgegeben werden, weswegen der Pfeil << in diese Richtung zeigt. Das Objekt cin soll die
Tastatur repräsentieren, aus der Daten in Variable fließen, deswegen zeigt der Pfeil >> von cin aus in Richtung Variable.

2000-06

datadidact
1-13

Programmieren mit C++

C++ Programmierung

L8

1 Grundlagen der Programmierung in C++

Wertzuweisung, Rechenoperationen

Die Wertzuweisung an eine Variable erfolgt über den Operator „=“, z.B.
a=5;
ergebnis=x*faktor+abstand-12;

Das erste Beispiel weist der Variablen a den Wert 5 zu. Im zweiten Beispiel wird eine Formel berechnet, das
Ergebnis der Berechnung wird der Variablen mit Namen ergebnis zugewiesen.
Der Zuweisungsoperator „=“ muss wie ein Pfeil nach links („←“) verstanden werden. Rechts vom „=“ kann
ein beliebig komplexer mathematischer oder logischer Ausdruck stehen, links muss immer ein einzelner Variablenname stehen, in dem das Ergebnis des Ausdrucks gespeichert werden kann (L-Wert, Linkswert oder
Lvalue genannt). Daher muss eine Wertzuweisung immer von rechts nach links gelesen werden - sie ist in der
Wirkung nicht identisch mit einer mathematischen Gleichung!
// Beispiele für Wertzuweisungen:
int a;
a = 3;
// Der Wert 3 wird in der Variablen a gespeichert
a = a + 5; // 3 wird aus a entnommen, 5 wird addiert, das Ergebnis 8 wird
// wieder in a gespeichert : wäre als Gleichung falsch!
a + 5 = a

// Nicht kompilierbar - Fehlermeldung „Lvalue required“

C++ bietet die Grundrechenarten Addition, Subtraktion, Multiplikation und Division an.
Addition, Subtraktion, Multiplikation und Division werden durch die Operatoren +, -, * und / ausgeführt; der
Ergebnistyp richtet sich dabei immer nach dem größten beteiligten Operandentyp. int+int ergibt z.B. int, aber
long+float ergibt float.
Ergänzend zur Ganzzahl-Division gibt es noch den Operator %, der den Rest der ganzzahligen Division errechnet.
C++ beachtet die Punkt-vor-Strich-Regel, so dass Multiplikation und Division vor Addition und Subtraktion
ausgeführt werden. Auch runde Klammern (...) können wie gewohnt eingesetzt werden.
Formel
17+5
12*1.5
12/4.0
12/4
17/3
17/3.0
17%3

Ergebnis
22
18.0
3.0
3
5
5.66666666667
2

Ergebnistyp
(int)
(float)
(float)
(int)
(int)
(float)
(int)

Bemerkung
int*float

17:3=5 Rest 2

Bei komplizierteren mathematischen Formeln müssen evtl. Klammern gesetzt werden, da z.B. Bruchstriche in
C++ nicht gesetzt werden können.
Beispiele:

x=

a+b
− e : x=(a+b)/(c+d)-e; ist richtig, falsch wäre x=a+b/c+d-e;
c+d

y=

a 2 − bc
− 7 : y=(a*a-b/c)/(d/(e+f)+g)-7
d
g
e+ f +

Programmieren mit C++

datadidact
1-14

2000-06

1 Grundlagen der Programmierung in C++

L9

C++ Programmierung

Implizite und explizite Typkonvertierung

Was passiert, wenn bei einer Zuweisung die Formel einen anderen Typ hat, als die Variable, der der Wert zugewiesen werden soll?
Beispiel:
long a,e;
float b;
e=a/b;

Das Ergebnis der Formel a/b ist vom Typ float, weil b vom Typ float ist. Aber e ist eine long-Variable. Daher
muss der Ergebnistyp dem Variablentyp von e angepasst werden. Solche Anpassungen können implizit vorgenommen werden, wie in diesem Beispiel, oder sie können auch explizit vorgegeben werden.
Bei geeignetem Programmzusammenhang erfolgt die Typumwandlung automatisch (implizit). Zusätzlich kann
der Programmierer explizite Typ-Konvertierungen (engl. type casting) vornehmen.
Beispiele:
int i,j;
bool a,b;
char z;
a
i
j
b

=
=
=
=

true;
int(a);
7;
bool(j);

j
i
b
z
i

=
=
=
=
=

0;
a;
j;
’Ç’;
z;

L10

// keine Konvertierung
// explizit: int(true) ist 1, daher ist i gleich 1
// keine Konvertierung
// explizit: bool(7) ist true, daher ist b gleich true
// Jede Ganzzahl <> 0 ergibt als bool-Wert true
// keine Konvertierung
// implizit: i wird auf 1 gesetzt
// implizit: b wird auf 0 gesetzt
// keine Konvertierung; Zeichen mit ASCII-Wert 128
// implizit: Aufpassen: i auf -128 gesetzt, da i ein
// signed int ist

Inkrement- und Dekrementoperatoren

C++ erlaubt spezielle Schreibweisen für Operationen, die sich auf eine einzige Variable beziehen. Soll der
Wert einer Variablen erhöht (inkrementiert) oder vermindert (dekrementiert) werden, kann man folgende
Schreibwiesen anwenden:
int i=3,a=6;
i+=15;
// i
i-=17*a; // i
++i;
// i
i++;
// i
--i;
// i
i--;
// i
i*=17;
// i
i/=2*a; // i
i%=a;
// i

2000-06

wird
wird
wird
wird
wird
wird
wird
wird
wird

um 15 erhöht
um 17*a vermindert
um 1 erhöht. Inkrement-Operator (Pre-Inkrement)
um 1 erhöht. Inkrement-Operator (Post-Inkrement)
um 1 vermindert. Dekrement-Operator (Pre-Dekrement)
um 1 vermindert. Dekrement-Operator (Post-Dekrement)
mit 17 multipliziert
durch 2*a dividiert
der Divisionsrest von i/a zugewiesen

datadidact
1-15

Programmieren mit C++

C++ Programmierung

1 Grundlagen der Programmierung in C++

Der Unterschied, ob man die Operatoren ++ bzw. – vor oder nach der Variablen platziert, ist erst wichtig,
wenn die Operatoren innerhalb von Ausdrücken verwendet werden:
++i: Zuerst wird i inkrementiert, dann wird mit diesem i im Ausdruck weitergerechnet (analog für --i)
i++: Zuerst wird der Ausdruck mit dem momentanen Wert von i berechnet, danach wird i inkrementiert
(analog für i--)
Beispiele:
int i=10, j=5, k;
k = i*j++;
// jetzt hat k hat den Wert 50, j hat den Wert 6
int i=10, j=5, k;
k = i*++j;
// jetzt hat k den Wert 60, j hat den Wert 6.

Testen Sie dazu das folgende Programmbeispiel KurzOp.cpp.
// PROGRAMM KurzOp.cpp
// Inkrement-, Dekrement- und Zuweisungsoperationen testen.
#include <iostream.h>
void main()
{
int i, j;
cout << "Ganze Zahl eingeben: ";
cin >> j;
i = 1000 * ++j;
cout << "Inkrement-Operator vor der Variablen ergibt: " << i << endl;
j--; // Erhöhung zurücknehmen
i = 1000 * j++;
cout << "Inkrement-Operator nach der Variablen ergibt: " << i << endl;
j = 5;
i += j;
cout << "Addition um 5 ergibt: " << i << endl;
i -= j;
cout << "Subtraktion von 5 ergibt: " << i << endl;
i *= j;
cout << "Multiplikation mit 5 ergibt: " << i << endl;
}
Ganze Zahl eingeben: 3
Inkrement-Operator vor der Variablen ergibt: 4000
Inkrement-Operator nach der Variablen ergibt: 3000
Addition um 5 ergibt: 3005
Subtraktion von 5 ergibt: 3000
Multiplikation mit 5 ergibt: 15000

Programmieren mit C++

datadidact
1-16

2000-06

1 Grundlagen der Programmierung in C++

C++ Programmierung

1.3 Folge (Sequenz)
Lerninhalte

L1

!
"
#

Darstellung der Folge im Struktogramm

Lerninhalte

Benutzerfreundlichkeit
Anfangsprobleme und deren Lösungen

Darstellung der Folge im Struktogramm

Sollen für die Lösung einer Aufgabe einfach nur mehrere Anweisungen hintereinander ausgeführt werden,
können sie im Algorithmus in der gleichen Reihenfolge beschrieben werden.

Das Beispielprogramm Erstprog.cpp entspricht folgendem (ausführlichem) Struktogramm.

L2

Benutzerfreundlichkeit

Kommt es einem nur auf das Wesentliche an, kann man dieses Struktogramm auch wie folgt verkürzen.
Die Verkürzungen, die hier möglich waren, beziehen sich auf das Thema „benutzerfreundliche Programmierung“. Wenn im zweiten Struktogramm steht „E: a,b“, ist damit
die benutzerfreundliche Eingabe von a und b gemeint, die die entsprechenden Ausgaben
von Eingabeaufforderungen beinhalten. Durch diese Verkürzungen lenken im
Struktogramm die benutzerfreundlichen Teile nicht von den wesentlichen Teilen der
Programmierung ab.

2000-06

datadidact
1-17

Programmieren mit C++

C++ Programmierung

1 Grundlagen der Programmierung in C++

Es ist dennoch wichtig, dass sichergestellt ist, dass vor jeder Eingabe eine Ausgabe erfolgt, die dem Benutzer
genau beschreibt, was er denn nun eingeben soll.
Grundlegende Aufgabe

ErstProg2.cpp

Verändern Sie das erste Beispielprogramm, so dass es die Differenz der beiden eingegebenen Zahlen ausgibt.
Grundlegende Aufgabe

Benzinv.cpp

Schreiben Sie ein Programm, das nach Eingabe der gefahrenen Kilometer und der Menge des verbrauchten
Kraftstoffes den Durchschnittsverbrauch auf 100km berechnet und ausgibt.
Berechnung des Durchschnittsverbrauchs
verbrauchter Kraftstoff in l: 32.3
gefahrene Strecke in km: 423.1
Der Durchschnittsverbrauch ist 7.63 l/100km.
Programmende.

Grundlegende Aufgabe

Ganzteil.cpp

Das ganzzahlige Ergebnis und der Rest der Division von zwei einzugebenden ganzen Zahlen sollen mit einem
Programm berechnet werden.
Ganzzahlige Division mit Rest
Dividend: 23
Divisor: 4
Das Ergebnis der Division 23:4 ist 5 Rest 3
Programmende

Grundlegende Aufgabe

ParallelR.cpp

Der Gesamtwiderstand zweier parallelgeschalteter Widerstände soll nach der Eingabe der beiden Widerstandswerte berechnet werden.

Rg =

R1 ⋅ R2
R1 + R2

Widerstands-Parallelschaltung
R1 in Ohm: 12000
R2 in Ohm: 10000
Der Widerstand der Gesamtschaltung ist 5454.545 Ohm
Programmende

Grundlegende Aufgabe
DraWi.cpp
Nach Eingabe des Durchmessers d und der anderen Größen soll der Drahtwiderstand R eines Kupferdrahtes
nach folgender Formel berechnet und ausgegeben werden.
l
m
R = ρ mit ρ = 56
A
Ω ⋅ mm 2
ρ (rho) ist der spezifische Widerstand von Kupfer, l ist die Länge des Drahtes, A ist die Querschnittsfläche des
Drahtes. Verwenden Sie RHO als Konstante in Ihrem Programm.

Programmieren mit C++

datadidact
1-18

2000-06

1 Grundlagen der Programmierung in C++

C++ Programmierung

Drahtwiderstand in Ohm
Durchmesser in mm: 1.5
30
Laenge in m:
Bei 1.5 mm Durchmesser betraegt der Drahtwiderstand 0.303152 Ohm

Grundlegende Aufgabe
WarmWi.cpp
Nach der numerischen Eingabe der entsprechenden Größen soll der Temperaturunterschied ∆T und der Wert
des Warmwiderstandes RW ausgegeben werden.

RW = RK (1 + α ⋅ ∆T )
Dabei ist RK der Kaltwiderstand in Ω , RW der Warmwiderstand in Ω , α ist der Temperaturkoeffizient in 1/K,
∆T der Temperaturunterschied in °C.
Berechnung des Warmwiderstands
Kaltwiderstand in Ohm
Temperaturkoeffizient in 1/K
Temperaturdifferenz in Grad
Der Warmwiderstand betraegt

Grundlegende Aufgabe

: 100
: 0.0039
C : 60
123.4 Ohm

Pythagor.cpp

Entwickeln Sie ein Struktogramm und C++ Programm, welches für ein rechtwinkliges Dreieck bei Eingabe
beliebiger Katheten a und b die Hypothenuse c und die beiden Winkel α und β berechnet und ausgibt.
Hinweise:

c = a2 + b2 ,

α Grad α Bogen
b
, α Bogen = arctan( )
=
o
a

360

Sie benötigen die zusätzliche Bibliothek math.h. Die mathematische Funktion sqrt() für die Berechnung der
Quadratwurzel, atan() für die Berechnung des Arcustangens und die Konstante M_PI für die Kreiszahl π
finden Sie dort unter Anwendung der Online-Hilfe. Verwenden Sie in Ihrem Programm alpha,
alpha_bogen, beta und beta_bogen als Variablennamen, wenn benötigt.
Berechnung RECHTWINKLIGES D R E I E C K
Kathete a in mm: 356
Kathete b in mm: 435
Die Hypothenuse c ist c = 562.104 mm.
Winkel alpha = 50.7034 Grad, Winkel beta = 39.2966 Grad.

2000-06

datadidact
1-19

Programmieren mit C++

1 Grundlagen der Programmierung in C++

C++ Programmierung

Grundlegende Aufgabe

Dreieck1.cpp

Ergänzen Sie den Programmtext und erklären Sie den Namen Dreieck1:
//Programm Dreieck1.cpp;
...
int zahl1,zahl2,.....;
cout<< "Geben Sie zwei Zahlen ein:" << endl;
cout "Zahl1: "; cin >> zahl1;
cout "Zahl2: "; cin >> zahl2;
..................;
..................;
..................;
cout<< "Die Zahlen sind jetzt: " << zahl1 << "

" << zahl2;

Geben Sie zwei Zahlen ein:
Zahl1: 15
Zahl2: 24
Die Zahlen sind jetzt: Zahl1=24 Zahl2=15

L3

Anfangsprobleme und deren Lösungen

Bei den ersten Übungen entstehen normalerweise Probleme, von denen hier eine Auswahl mitsamt Lösungen
angegeben sind.
1. Vergessene Strichpunkte (Syntaxfehler)
Einzelne Anweisungen werden stets durch Strichpunkt getrennt. Wurde dieser hinter einer Anweisung vergessen, wird beim Übersetzen meist ein Fehler bei der folgenden Anweisung angemahnt. Beispiele (die , zeigt
die echte Fehlerstelle, die - die vom Compiler angezeigte Fehlerstelle an):
„Statement missing ;“ ist eine sehr klare Fehlermeldung in diesem Fall. Der Fehler wird aber leider hinter der
Fehlerstelle angezeigt.
cout << "Hallo",
cin ->> a;

„Declaration syntax error“ kann seine Ursache auch in einem fehlenden Strichpunkt nach einer
Variablendeklaration haben.
int a,b,
cout -<< "Hallo";

Falsch geschriebene Worte (Syntaxfehler)
„Undefined Symbol ‘XXX’“ bedeutet, dass der Compiler mit dem Wort XXX nichts anfangen kann. Eine mögliche Ursache ist ein Schreibfehler, wie im folgenden Fall mit dem Schlüsselwort Cout als XXX:
,Cout << -"Hallo";

Eine weitere Ursache ist eine falsche Variablendeklaration, wie im folgenden Fall mit Summe als XXX:
float ,summe;
cout << Summe;-

Programmieren mit C++

datadidact
1-20

2000-06

1 Grundlagen der Programmierung in C++

C++ Programmierung

2. Ausgabe verschwindet sofort nach Programmende
Um die Programmausgabe nach dem Ablauf des Programms weiter anzuzeigen, hält man durch das Setzen
einer Unterbrechung (Breakpoint) nach dem letzten Programmbefehl das Programm an dieser Stelle an. In der
Borland-C++-Entwicklungsumgebung kann man dazu den Cursor auf die letzte geschweifte Klammer im Programm setzen und dann die Taste F4 betätigen (Das bedeutet: Führe das Programm aus bis zur Cursorposition
im Quelltext). Durch Mausklick auf das Programmsymbol in der Taskleiste holt man den Programmbildschirm
wieder in den Vordergrund.
Das Bildschirmfenster bleibt auch offen, wenn man als letzten Befehl das Programm auf eine Eingabe warten
lässt. Dazu ist der folgende Befehl getch() geeignet:
#include <iostream.h>
#include <conio.h>
...
void main()
{
...
getch(); // erfordert #include <conio.h>, Programmende nach Tastendruck
}

3. Merkwürdiges Zahlenformat bei der Ausgabe
Fließkommazahlen werden manchmal mit einer unerwünscht hohen Genauigkeit oder in wissenschaftlicher
Notation (+1E+20 für 1020) angegeben. Auch die genaue Ausgabebreite liegt nicht fest, was bei Tabellen
wichtig ist. In C++ kann man mit folgenden Anweisungen die Anzahl der Vor- und Nachkommastellen genau
festlegen.
cout.setf(ios::fixed); // muss einmal am Anfang des Programmes stehen
cout.width(20);
// die Gesamtbreite der Ausgabe wird bestimmt
cout.precision(3);
// Anzahl der Nachkommastellen
cout << f1 << f2;
// Vorsicht! Die Formatierung mit width() gilt genau einmal,
nämlich für f1, f2 wird wieder mit variabler Gesamtbreite ausgegeben.

Die Anweisung cout.setf(ios::fixed); legt fest, dass das Programm bei Ausgaben auf den Bildschirm nicht mit Fließkommadarstellung, sondern mit Festkommadarstellung arbeiten will. Deswegen legt
dann die Anweisung cout.precision(3); fest, mit wie vielen festen Nachkommastellen gearbeitet
werden soll. Diese beiden Einstellungen haben ständige Gültigkeit, man kann damit am Anfang eines
Programms eine gewisse Ausgabegenauigkeit festlegen.
Soll auch die Anzahl der Stellen vor dem Komma festliegen, muss mit cout.width(V+N+1); die
Ausgabebreite der gesamten Zahl gesetzt werden. V ist die Anzahl der gewünschten Vorkommastellen, N die
der Nachkommastellen. Leider muss die Ausgabebreite vor der Ausgabe jeder Variablen neu eingestellt
werden.
4. Semantische (logische) Fehler
Im Gegensatz zu syntaktischen Fehlern können semantische Fehler nicht vom Compiler festgestellt werden, da
semantische Fehler durch einen falschen Sinn der Anweisungen entstehen, nicht durch feststellbar falsche
Schreibung.
summe=a,-b;
// Eigentlich soll nicht die Differenz berechnet werden
cout << summe;

Dieses Programm wird übersetzt und ausgeführt, liefert aber wegen eines falschen Rechenzeichens ein falsches
Ergebnis. Es ist syntaktisch korrekt, aber semantisch falsch.

2000-06

datadidact
1-21

Programmieren mit C++

C++ Programmierung

1 Grundlagen der Programmierung in C++

1.4 Auswahl (Selektion)
In Abhängigkeit von einer Bedingung werden Anweisungen ausgeführt oder weggelassen. Diese Bedingungen
sind in der Regel an Operatoren wie > (größer als), < (kleiner als), == (gleich) und != (ungleich) geknüpft.

! Einseitige Auswahl
" Logische Vergleichsoperatoren
# Probleme und deren Lösung bei einseitiger Auswahl
$ Zweiseitige Auswahl
%& Mehrseitige Auswahl
' Probleme und deren Lösung bei zwei- und mehrseitiger Auswahl

Lerninhalte

L1

Lerninhalte

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.
Die Syntax lautet in C++:
if (Bedingung) Anweisung;

Beispiel:
if (SparkontoGuthaben >= AbbuchungsBetrag)
SparkontoGuthaben -= AbbuchungsBetrag;

Sollen mehrere Anweisungen in Abhängigkeit der Bedingung ausgeführt werden, muss diese
Anweisungsgruppe mit {...} geklammert werden.
if (SparkontoGuthaben>=UmbuchungsBetrag)
{
SparkontoGuthaben -= UmbuchungsBetrag;
GirokontoGuthaben += UmbuchungsBetrag;
}

Die angegebene Bedingung ist entweder wahr oder falsch, sie nimmt also die booleschen Werte true oder
Programmieren mit C++

datadidact
1-22

2000-06

1 Grundlagen der Programmierung in C++

C++ Programmierung

false an. Boolesche Werte können mit den Operatoren „&&“ für UND bzw. „||“ für ODER verknüpft werden.
A
false
false
true
true

b
false
true
false
true

a && b
false
false
false
true

a
false
false
true
true

b
false
true
false
true

a || b
false
true
true
true

a&&b ist also nur dann wahr, wenn sowohl a als auch b wahr sind. Bei a||b genügt es, wenn mindestens
eines der beiden a oder b wahr ist.
Vergleichsoperationen werden vorrangig vor boolschen Operationen behandelt. Welchen Datentyp hat im folgenden Beispiel die Variable GuterKunde?
if (GirokontoGuthaben >= AbbuchungsBetrag ||
GirokontoGuthaben+Dispositionskredit >= Abbuchungsbetrag || GuterKunde)
GirokontoGuthaben -= AbbuchungsBetrag;

L2

Logische Vergleichsoperatoren

Die folgenden Operatoren für logische Vergleiche sind definiert:
Operator
<
<=
>
>=
= =
!=

Aufgabe
kleiner als
kleiner oder gleich
größer als
größer oder gleich
gleich
ungleich

Beispiel
if (i < 1)
if (i <= 1)
if (i > 1)
if (i >= 1)
if (i = = 1)
if (i != 1)

Das Ergebnis eines Vergleichs ist immer ein Ausdruck vom Typ bool, also ein Wahrheitswert true oder false.
Insbesondere darf der Operator „= =“ nicht verwechselt werden mit dem Zuweisungsoperator „=“ – die Wirkung ist eine vollkommen andere.
if (i=1) cout << “Logischer Fehler!“;
// Die Variable i wird auf 1 gesetzt. Dann ergibt sich:
// Der Ausdruck hinter if ist immer true, da ungleich 0

Der Compiler warnt hier übrigens mit der Meldung „Possibly incorrect assignment“.

2000-06

datadidact
1-23

Programmieren mit C++

1 Grundlagen der Programmierung in C++

C++ Programmierung

Grundlegende Aufgabe

Bestell.cpp

Eine Firma liefert bei einem Bestellwert ab 200,-DM porto- und verpackungsfrei. Für Aufträge unter 200.-DM
beträgt die Versandpauschale 5,50DM. Ein Programm soll den Rechnungsbetrag in Abhängigkeit vom Bestellwert ausgeben.
Berechnung des Rechnungsbetrages
Bestellwert in DM: 150
Rechnungsbetrag: 155.5 DM
Programmende.
Berechnung des Rechnungsbetrages
Bestellwert in DM: 250
Rechnungsbetrag: 250 DM
Programmende.

Grundlegende Aufgabe

Versand1.cpp

Ein Versandhaus berechnet bei Nettobeträgen unter 150,-DM Verpackungskosten von 5,-DM. Bei Beträgen
ab 150,-DM erhält der Kunde 2% Rabatt. Schreiben Sie Struktogramm und Programm!
Rechnung Versandhaus
Geben Sie den Nettobetrag in DM ein: 89
Rabatt: 0
Der Rechnungsbetrag betraegt: 94 DM.
Darin enthalten sind der Rabatt von 0 DM und 5 DM Verpackungskosten.
Rechnung Versandhaus
Geben Sie den Nettobetrag in DM ein: 345
Rabatt: 0.02
Der Rechnungsbetrag betraegt: 338.1 DM.
Darin enthalten sind der Rabatt von 6.9 DM und 0 DM Verpackungskosten.

Grundlegende Aufgabe

Dreieck.cpp

Ein Dreieck lässt sich aus den Seiten a, b und c konstruieren, wenn die Dreiecksungleichungen a+b>c, a+c>b,
b+c>a gelten. Schreiben Sie ein Programm, das bei einzugebenden Seiten überprüft, ob sich das Dreieck konstruieren lässt.
Konstruierbarkeit eines Dreiecks pruefen
Seite a: 12.5
Seite b: 12.5
Seite c: 12.5
Das Dreieck ist konstruierbar.
Programmende.
Konstruierbarkeit eines Dreiecks pruefen
Seite a: 12.5
Seite b: 10
Seite c: 25
Das Dreieck ist nicht konstruierbar.
Programmende.

Weiterführende Aufgabe

LinGl.cpp

Die Gleichung ax+b=0 soll für einzulesende Werte a und b vom Computer gelöst werden. Denken Sie
daran, dass sowohl a als auch b den Wert 0 annehmen können.
Programmieren mit C++

datadidact
1-24

2000-06

1 Grundlagen der Programmierung in C++

L3

C++ Programmierung

Probleme und deren Lösung bei einseitiger Auswahl

Dieser Abschnitt weist auf einige typische Fehler bei der einfachen Auswahl hin.
1. Strichpunkt nach if (semantischer Fehler)
Die Auswirkung dieses Fehlers ist meist, dass Programmteile immer ausgeführt werden, obwohl sie nur unter
bestimmten Bedingungen ausgeführt werden sollen. Der „bedingte Teil“ des untenstehenden Programmfragmentes wird immer ausgeführt, weil für den Compiler die bedingte Anweisung die leere Anweisung vor dem
Strichpunkt ist. Der Block in {} wird daher ohne Bedingung ausgeführt.
if (D<0);,
{
D=-D; // Vorzeichen umdrehen
cout << "Vorzeichen umgedreht." << endl;
}

2. Vergessene geschweifte Klammern (semantischer Fehler)
Die Auswirkung dieses Fehlers ist meist, dass Programmteile immer ausgeführt werden, obwohl sie nur unter
bestimmten Bedingungen ausgeführt werden sollen. Der „bedingte Teil“ des untenstehenden Programmfragmentes soll der eingerückte Teil sein. Da der Compiler Einrückungen aber nicht beachtet, wird nur die erste
Anweisung nach dem if() bedingt ausgeführt, die Ausgabeanweisung dagegen immer.
if (D<0),
D=-D; // Vorzeichen umdrehen
cout << "Vorzeichen umgedreht." << endl;
,

Richtig wäre:
if (D<0)
{
D=-D; // Vorzeichen umdrehen
cout << "Vorzeichen umgedreht." << endl;
}

3. Zuweisung statt Vergleich (semantischer Fehler)
Verwechselt man den Vergleichsoperator == mit dem Zuweisungsoperator =, erhält man vom Compiler eine
Warnung „Possibly incorrect assignment“. In der folgenden Zeile ist der Bedingungsausdruck niemals wahr,
obwohl nach Ausführen der Anweisung garantiert D=0 ist; die Ausgabe wird nie getätigt.
if (D=,0) cout << "D ist 0!" << endl;

D=0 ist eine Zuweisung an D, wonach D den Wert 0 erhält. Der Wert des gesamten Ausdrucks ist auch 0, was
logisch „falsch“ entspricht. Damit wird die Ausgabeanweisung nie ausgeführt. richtig wäre hier:
if (D==0) cout << "D ist 0!" << endl;

2000-06

datadidact
1-25

Programmieren mit C++

1 Grundlagen der Programmierung in C++

C++ Programmierung

L4

Zweiseitige Auswahl
Bei der zweiseitigen Auswahl wird in Abhängigkeit davon, ob eine
Bedingung erfüllt ist oder nicht, jeweils eine bestimmte Anweisung oder
Anweisungsgruppe ausgeführt.
Die Syntax lautet in C++:
if (Bedingung) Anweisung1; else Anweisung2;

Man kann die zweiseitige Auswahl also als eine Erweiterung der einseitigen Auswahl um eine Alternative
betrachten. Beachten Sie: die else-Anweisung bezieht sich immer auf das letzte, nicht durch else
abgeschlossene if im gleichen Block.
Beispiel:
if (SparkontoGuthaben >= AbbuchungsBetrag)
SparkontoGuthaben -= AbbuchungsBetrag;
else
AbbuchungsBetrag=0;
if (SparkontoGuthaben >= UmbuchungsBetrag)
{
SparkontoGuthaben -= UmbuchungsBetrag;
GirokontoGuthaben += UmbuchungsBetrag;
}
else
{
UmbuchungsBetrag = SparkontoGuthaben;
SparkontoGuthaben = 0;
GirokontoGuthaben += UmbuchungsBetrag;
}

Sollen mehrere Anweisungen in Abhängigkeit der Bedingung ausgeführt werden, muss diese
Anweisungsgruppe wieder mit geschweiften Klammern { } gruppiert werden.

Programmieren mit C++

datadidact
1-26

2000-06

1 Grundlagen der Programmierung in C++

C++ Programmierung

Zweiseite Auswahl mit Bedingungsoperator:
Falls es nur darum geht, eine bedingte Zuweisung zu treffen, kann man eine ganz rasche zweiseitige Auswahl
mit dem Bedingungsoperator „?“ treffen:
Ergebnis = Bedingung ? AusdruckBeiWahr : AusdruckBeiFalsch;

Zuerst wird die Bedingung ausgewertet. Ist sie wahr, dann ist das Ergebnis gleich AusdruckBeiWahr,
ansonsten AusdruckBeiFalsch.
Beispiel:
int Max;
Max = a>b ? a:b; // if (a>b) Max = a; else
Max = b;

Im Struktogramm muss man dies ausführlich
darstellen.

Grundlegende Aufgabe

BenzinV2.cpp

Schreiben Sie ein Programm, das nach Eingabe der gefahrenen Kilometer und der Menge des verbrauchten
Kraftstoffes den Durchschnittsverbrauch auf 100km berechnet und ausgibt. Die Berechnung darf aber nur
erfolgen, wenn die gefahrenen Kilometer ungleich null sind, ansonsten soll eine (sinnvolle) Fehlermeldung
ausgegeben werden.
Berechnung des Durchschnittsverbrauchs
verbrauchter Kraftstoff in l: 32.3
gefahrene Strecke in km: 0
Ungueltige Strecke eingegeben.
Programmende.

Grundlegende Aufgabe

Bestell2.cpp

Eine Firma liefert bei einem Bestellwert ab 200,-DM porto- und verpackungsfrei. Für Aufträge unter 200.-DM
beträgt die Versandpauschale 5,50DM. Ein Programm soll den Rechnungsbetrag in Abhängigkeit vom
Bestellwert ausgeben.
Berechnung des Rechnungsbetrages
Bestellwert in DM: 150
Rechnungsbetrag: 155.5 DM
Programmende.
Berechnung des Rechnungsbetrages
Bestellwert in DM: 250
Rechnungsbetrag: 250 DM
Programmende.

Grundlegende Aufgabe

Versand2.cpp

Schreiben Sie das Programm Versand1.cpp so um, dass eine zweiseitige Auswahlstruktur verwendet wird.
Grundlegende Aufgabe

Bestell3.cpp

Die Elektronikfirma Kleinkram erhebt für Bestellungen unter 100,-DM einen Porto- und Verpackungsanteil
2000-06

datadidact
1-27

Programmieren mit C++

1 Grundlagen der Programmierung in C++

C++ Programmierung

von 5,50DM, von 100,-DM bis 200,-DM einen Betrag von 3,-DM, ab 200,-DM werden keine Spesen
berechnet. Ein Programm soll bei gegebener Auftragssumme den Rechnungsbetrag ausgeben.
Berechnung des Rechnungsbetrages
Auftragssumme in DM: 150
Rechnungsbetrag: 153.00 DM
Programmende.

Grundlegende Aufgabe

Widerstand.cpp

Nach Eingabe von zwei Widerstandswerten wird wahlweise der Gesamtwiderstand zweier parallel oder in
Reihe geschalteter Widerstände berechnet.
R ⋅R
Bei Reihenschaltung: Rg = R1 + R2
Bei Parallelschaltung: R g = 1 2
R1 + R2
Widerstands-Schaltung
(P)arallel- oder (R)eihenschaltung? P
R1 in Ohm: 12000
R2 in Ohm: 10000
Der Widerstand der Parallelschaltung ist 5454.545 Ohm
Programmende

Grundlegende Aufgabe

KinderG.cpp

Eine Familie in Kautschukistan erhält nach folgender einkommensabhängiger Tabelle Kindergeld. Ein
Programm ist gesucht, das nach Eingabe der Kinderzahl und des Einkommens das zu zahlende Kindergeld
berechnet.
Einkommen
für das 1. Kind
für das 2. Kind
für das 3. Kind
ab dem 4. Kind

< 45.000,- Talente
70 Talente
130 Talente
220 Talente
240 Talente

Weiterführende Aufgabe

ab 45.000,- Talente
70 Talente
70 Talente
140 Talente
140 Talente

Geraden.cpp

Der Schnittpunkt von 2 Geraden ist gesucht. Gerade 1 wird durch die Punkte A(ax,ay) und B(bx,by), Gerade 2
durch die Punkte C(cx,cy) und D(dx,dy) angegeben. Denken Sie daran, dass die Geraden auch parallel sein
können, dies muss besonders beachtet werden.
Es gilt: (bx - ax) y = (by - ay) x + (ay bx - ax by) und (dx - cx) y = (dy - cy) x + (cy dx - cx dy)
Die Geraden sind parallel, wenn gilt: (by - ay) (dx - cx) - (dy - cy) (bx - ax) = 0
Weiterführende Aufgabe

Resistor.cpp

Schreiben Sie ein Struktogramm und Programm, in dem wahlweise der Gesamtwiderstand für eine Reihenoder Parallelschaltung von drei Widerständen berechnet werden soll.
Weiterführende Aufgabe

Skonto.cpp

Schreiben Sie das Programm nach folgendem Struktogramm:

Programmieren mit C++

datadidact
1-28

2000-06

1 Grundlagen der Programmierung in C++

Weiterführende Aufgabe

C++ Programmierung

Ungerade.cpp

Wie lautet die Auswahlstruktur des Programms Ungerade.cpp?// Programm Ungerade.cpp
...
int zahl;
cout << "Eine Zahl eingeben: "; cin >> zahl;
...
Gerade oder ungerade?
Eine Zahl eingeben: 66
66 ist eine GERADE Zahl.
Gerade oder ungerade?
Eine Zahl eingeben: 7
7 ist eine UNGERADE Zahl.

L5

Mehrseitige Auswahl

Es gibt zwei Formen der mehrseitigen Auswahl, die sich darin unterscheiden, wie man sie programmieren
kann. Die erste Art ist sehr speziell und beruht darauf, dass die einzelnen Fälle sich durch feste Einzelwerte
bestimmen lassen.

Die mehrseitige Auswahl stützt ihre Wahl auf einen abzählbaren Datentyp, den Selektor, der mehr als zwei
Werte annehmen kann, z.B. int oder char. In Abhängigkeit des aktuellen Wertes wird dann eine von vielen
Möglichkeiten ausgewählt und ausgeführt.
Die Syntax lautet in C++:
switch(c)
{
case m1:
case m2:
case m3:
case m4:
case m5:
case m6:
default:
}

Anweisung1; break;
Anweisung2; break;
Anweisung34; break;
Anweisung56; break;
AnweisungS;

Der default-Teil kann auch weggelassen werden.
2000-06

datadidact
1-29

Programmieren mit C++

C++ Programmierung

1 Grundlagen der Programmierung in C++

Beispiel:
switch (wochentag)
{
case Montag: case Dienstag:
case Mittwoch: case Freitag:
case Donnerstag:
default:
}

cout << "Werktag";
break;
cout << "Langer Werktag"; break;
cout << "Wochenende";

Auch mehrere Anweisungen in Abhängigkeit der Bedingung sind möglich, dabei kommt es aber auf das
Beenden der Anweisungsfolge mit break an, die Anweisungen müssen nicht geklammert werden.
switch (wochentag)
{
case Montag: case Dienstag:
case Mittwoch: case Freitag:
case Donnerstag:
default:

cout << "Werktag";
Werktag=true;
break;
cout << "Langer Werktag"
Werktag=true;
break;
cout << "Wochenende";
Werktag=false;

}

Mehrseitige Auswahl mit verschachtelten if()-else()-Anweisungen
Falls der Selektor kein abzählbarer Datentyp ist oder die Bedingungen für die einzelnen Fälle komplizierter
sind, muss auf eine verschachtelte zweiseitige Auswahl zurückgegriffen werden. Dabei taucht die breakAnweisung aber nicht mehr auf, sondern mehrere Anweisungen werden wie bei der zweiseitigen Auswahl mit
geschweiften Klammern geklammert.

Programmieren mit C++

datadidact
1-30

2000-06

1 Grundlagen der Programmierung in C++

C++ Programmierung

Beispiel:
// a ist vom Typ float und damit nicht abzaehlbar
if
(a<1.7) b=1;
else if (a<2.5) { b=2; cout << "Fall 2" << endl; }
else if (a<4.0) b=3;
else
b=4;
// komplexe Bedingungen
if
(a<5 && c>7) b=1;
else if (a<5 && c<=7) b=2;
else if (a>=5 && c>7) { b=3; cout << "Fall 3" << endl; }
else
b=4;

Merke: Bei verschachtelter zweiseitiger Auswahl gehört das letzte else immer zum direkt vohergehenden if.
if (Bedingung1) Anweis1; else if (Bedingung2) Anweis2; else Anweis3;
// ist das gleiche wie:
if (Bedingung1) Anweis1; else { if (Bedingung2) Anweis2; else Anweis3; }

Grundlegende Aufgabe

MonName.cpp

Schreiben Sie ein Programm, das die Monatsnamen „Januar“ bis „Dezember“ ausgibt, wenn eine der Zahlen
von 1 bis 12 eingegeben wird.
Ausgabe des Monatsnamens
Nummer des Monats (1..12): 4
Der 4. Monat heisst April.
Programmende.
Ausgabe des Monatsnamens
Nummer des Monats (1..12): 15
Es gibt nur 12 Monate!
Programmende.
2000-06

datadidact
1-31

Programmieren mit C++

1 Grundlagen der Programmierung in C++

C++ Programmierung

Grundlegende Aufgabe

Brief.cpp

Briefe werden nach ihrem Gewicht frankiert. Es gelten folgende Portobeträge:

Sendungen schwerer als 1kg werden als Päckchen oder Paket verschickt. Schreiben Sie ein Programm, das
nach Eingabe des Gewichtes das Porto ausgibt.
Portoberechnung
Gewicht des Briefes in g: 75.6
Kosten: 2.40 Talente
Programmende
Portoberechnung
Gewicht des Briefes in g: 1500
Das wird ein Paket!
Programmende

Grundlegende Aufgabe

urlaub1.cpp

Entwickeln Sie Struktogramm und Programm, welches für die Eingabe von Alter und Betriebsjahren Auskunft
über die Urlaubstage bei folgender Regelung gibt: 30 Tage (Alter unter 18), 28 Tage (von 18 bis einschl. 40
Jahre) oder 31 Tage Urlaub (ab 40 Jahren). Bei 10 oder mehr Jahren Betriebszugehörigkeit erhält man einen
und bei 25 oder mehr Jahren zwei Zusatztage zum Urlaub hinzu.
Grundlegende Aufgabe

Funktion.cpp

Ergänzen Sie den Quelltext und lassen Sie den Funktionswert sowie den x-Wert und den y-Wert ausgeben für
die Funktion, die folgendermaßen definiert ist:

 3 x − 2 für x < 1
y=
 y = 2 x + 1 für x ≥ 1
// Programm funktion.cpp
...
float x,y;
cout << "x-wert? "; cin >> x;
if ...

Weiterführende Aufgabe

QuadGl.cpp

Die quadratische Gleichung ax2 + bx + c = 0 ist zu lösen. Denken Sie daran, dass die Lösungen imaginär sein
können. Hinweis: Wurzeln werden in C++ mit der Funktion sqrt(x) berechnet, die in der Headerdatei
math.h deklariert wird.
Weiterführende Aufgabe

Volumen.cpp

Es sollen die Volumina und Oberflächen von Zylinder, Würfel, Quader, Kreiskegel oder Kugel berechnet
werden. Erstellen Sie ein Programm, das die Eingabe der Körperform und der notwendigen Maße erlaubt
und danach die Werte berechnet. Hinweis: Die Kreiszahl π ist in C++ in der Headerdatei math.h als
Konstante M_PI vereinbart.

Programmieren mit C++

datadidact
1-32

2000-06

1 Grundlagen der Programmierung in C++
Weiterführende Aufgabe

C++ Programmierung

Rechnen1.cpp

Schreiben Sie Struktogramm und C++- Programm, welches nach Eingabe von zwei Zahlen und eines
Operators (+, -, *, /) das Ergebnis berechnet. Die Eingabe eines falschen Rechenzeichens soll eine eindeutige
Reaktion hervorrufen.
Weiterführende Aufgabe

Noten1.cpp

Bei Facharbeiterprüfungen werden die erbrachten theoretischen Leistungen in Prozent berechnet. Die
Prozentangaben werden dann Notenbezeichnungen zugeordnet. Einzugeben ist der erreichte Prozentsatz. Liegt
eine Eingabe außerhalb des zulässigen Prozentbereiches, so soll eine Fehlermeldung auf dem Bildschirm
erscheinen. Schreiben Sie Struktogramm und Programm. Es gelten die Zuordnungen: 0-29 ungenügend, 30-49
mangelhaft, 50-66 ausreichend, 67-82 befriedigend, 83-92 gut, 93-100 sehr gut.
Weiterführende Aufgabe

Noten2.cpp

Das Programm Noten1.cpp ist so abzuwandeln, dass auch beliebig zu erreichende Punktzahlen umgerechnet
werden können.

L6

Probleme und deren Lösung bei zwei- und mehrseitiger Auswahl

Bei Verwendung der switch-Anweisung werden leicht einige spezielle Fehler gemacht. Auch bei
verschachtelten if()-else()-Konstruktionen wird oft Unbeabsichtigtes programmiert.
1. Selektor nicht abzählbar (Syntaxfehler)
Tritt folgende Fehlermeldung beim Übersetzen auf: „Switch selection
expression must be of integral type“, wurde versucht, in der SwitchAnweisung einen nicht abzählbaren Datentypen zu verwenden, wie z.B. float.

Verwenden Sie als Typen in der switch-Anweisung nur char, short, int oder
long (unsigned oder signed) oder selbstdefinierte enum-Typen.
Abhilfe 1 (Datentyp ändern):

Abhilfe 2 (kein switch verwenden):

float, i;
cin >> i;
switch (i){
case 1:...
case 2:...
...
}

int i;
cin >> i;
switch (i)
{
case 1:...
case 2:...
...
}

float i;
cin >> i;
if
(i>0.5 && i<=1.5) {...}
else if (i>1.5 && i<=2.5) {...}
else ...

2000-06

datadidact
1-33

Programmieren mit C++

C++ Programmierung

1 Grundlagen der Programmierung in C++

Vergessene break-Anweisung (semantischer Fehler)
Dieser Fehler äußert sich darin, dass plötzlich die
Aktionen mehrerer switch-Fälle nacheinander ausgeführt
werden.

Bei der Eingabe von 4, 5, 6 usw. wird korrekt „was anderes“
ausgegeben. Bei der Eingabe 1 dagegen wird
„Eins Zwei Drei was anderes“ ausgegeben, weil hinter der
Ausgabeanweisung cout << "Eins "; kein abschließendes
break; folgt, ebenso hinter den folgenden Ausgabeanweisungen.
Abhilfe:

int i;
cin >> i;
switch (i)
{
case 1: cout
case 2: cout
case 3: cout
default: cout
}
cout << endl;

int i;
cin >> i;
switch (i)
{
case 1:
case 2:
case 3:
default:
}
cout << endl;

cout
cout
cout
cout

<<
<<
<<
<<

<<
<<
<<
<<

"Eins ";,
"Zwei ";,
"Drei ";,
"was anderes";

"Eins "; break;
"Zwei "; break;
"Drei "; break;
"was anderes";

2. Falsche if()-else()-Konstruktionen (semantischer Fehler)
Diese äußern sich in wirren, unbeabsichtigten Reaktionen des Programms, genauer lassen sich die Folgen
dieses Fehlers leider nicht beschreiben. Beachten Sie im folgenden Programmfragment die Einrückungen, die
symbolisieren, was der Programmierer programmieren will.
if (D>0)
if (E>0) cout << "D und E sind beide positiv.";,
else
if (E<=0) cout << "D und E sind beide nicht positiv.";

Was der Programmierer tatsächlich programmiert hat, ist aber folgendes:
if (D>0)
if (E>0) cout << "D und E sind beide positiv.";
else
if (E<=0) cout << "D und E sind beide nicht positiv.";

Begründung: Eine else-Anweisung bezieht sich immer auf das zuletzt noch nicht durch else abgeschlossene if.
Abhilfe:
if (D>0)
{
if (E>0) cout << "D und E sind beide positiv.";
}
else
{ // diese geschweifte Klammer ist nicht notwendig, aber konsequent
if (E<=0) cout << "D und E sind beide nicht positiv.";
} // diese geschweifte Klammer ist nicht notwendig, aber konsequent

Dadurch muss die else-Anweisung sich auf die im Block vorhergehende if-Anweisung beziehen.

1.5 Wiederholung (Repetition)
In Abhängigkeit einer Bedingung werden Anweisungen wiederholt. Dabei ist zu unterscheiden zwischen
Bedingungen, die bereits am Schleifenanfang abgefragt werden und solchen, die erst beim Beenden der
Schleife geprüft werden.

Programmieren mit C++

datadidact
1-34

2000-06

1 Grundlagen der Programmierung in C++

Lerninhalte

L1

C++ Programmierung

! Schleife mit Endabfrage
" Probleme und deren Lösung
# Schleife mit Anfangsabfrage
$ Probleme und deren Lösungen
%& Die Zählschleife
' Zählschleife mit variabler Schrittweite
( Zählschleife mit lokal deklarierter Laufvariable
) Anweisungen für Schleifenabbruch

Lerninhalte

Schleife mit Endabfrage

Die Schleife mit Endabfrage wird mindestens einmal durchlaufen, sie wird auch als
fußgesteuerte Schleife bezeichnet. Die Schleife wird solange wiederholt, wie die
Bedingung wahr ist.
Die Syntax in C++ lautet:
do Anweisung while Bedingung;

Das folgende Beispiel wartet auf das Drücken
einer Taste J oder N:
cout << "Ja oder Nein? ";
do
{
cin >> c;
if (c!='J' && c!='j' &&
c!='N' && c!='n')
cout << (char)7;
}
while (c!='J' && c!='j' &&
c!='N' && c!='n');

Grundlegende Aufgabe

BenzinV3.cpp

Erweitern Sie das Programm BenzinV2.cpp, so dass so oft Kraftstoffverbrauch und Strecke eingegeben werden
können, bis der Benutzer abbricht.
Berechnung des Durchschnittsverbrauchs
verbrauchter Kraftstoff in l: 32.3
gefahrene Strecke in km: 352
Der Durchschnittsverbrauch ist 9.18l/100km.
Noch eine Berechnung? J
verbrauchter Kraftstoff in l: 45.7
gefahrene Strecke in km: 515
Der Durchschnittsverbrauch ist 8.87l/100km.
Noch eine Berechnung? N
Programmende.

Grundlegende Aufgabe

Teiler.cpp

Lassen Sie alle Teiler einer einzulesenden ganzen Zahl z ausgeben. Prüfen Sie dabei bei jeder Zahl i
zwischen 1 und z, ob der Divisionsrest von z/i gleich 0 ist. Beispiel: 8 hat die Teiler 1, 2, 4, 8.

2000-06

datadidact
1-35

Programmieren mit C++

1 Grundlagen der Programmierung in C++

C++ Programmierung

Grundlegende Aufgabe

Mittel1.cpp

Schreiben Sie ein Programm, welches solange den (gleitenden) Mittelwert von einzugebenden Daten ermittelt,
bis das Programm mit „N“ (Nein) abgebrochen wird. Die Anzahl der Daten ist vor dem Programmaufruf
unbekannt. Es ist dazu nötig, die Summe der eingegebenen Zahlen und die Anzahl der eingegebenen Zahlen
mitzuführen.
Mittelwertberechnung
1. Zahl: 15
Mittelwert: 15. Eine weitere Zahl? J
2. Zahl: 17.5
Mittelwert: 16.25. Eine weitere Zahl? J
3. Zahl: -20.5
Mittelwert: 4. Eine weitere Zahl? N
Programmende.

Grundlegende Aufgabe

Bremsen.cpp

Bei einem Bremsvorgang wird ein Auto mit 4,3m/sec2 gebremst. Ein Programm soll die Bremswege bis zu
einem einzugebenden maximalen Bremsweg in Tabellenform ausgeben, wobei die Geschwindigkeit von
5km/h beginnend in Schritten von 5km/h zu steigern ist. Gleichzeitig soll die Bremszeit berechnet und
ausgegeben werden.
Hinweis: s = v2 / (2 a); t = v / a
Grundlegende Aufgabe

Werttab1.cpp

Mit der do-while-Schleife soll eine formatierte Wertetabelle der Funktionsgleichung y = 0,1x³ - 2x² + 5 im
Bereich -10 <= x <= 10 erstellt werden. Lassen Sie die Anfangs- und Endwerte von x sowie eine beliebige
Schrittweite eingeben.
Weiterführende Aufgabe

Suppe.cpp

Eine Schüssel Suppe kühlt pro Minute um 19% der Differenz aus Suppentemperatur und
Umgebungstemperatur ab. Es soll die Temperatur der Suppe nach jeder Minute angegeben werden, wenn man
als Anfangstemperatur 90oC und als Umgebungstemperatur 20oC annimmt. Schreiben Sie das Programm so,
dass Suppen- und Umgebungstemperatur eingegeben werden können.
Weiterführende Aufgabe

Zins.cpp

Ein Kapital k wird mit Zinseszins verzinst. Lassen Sie ein Tabelle ausgeben, die den Betrag ausgibt, der am
Ende jeden Jahres auf dem Konto steht. Der Zinsfuß p, das Kapital k und der zu erreichende Kontostand bmax
sollen einzugeben sein.
Hinweis: b = k ( 1 + p / 100)n
Weiterführende Aufgabe

Binaer1.cpp

Schreiben sie Struktogramm und Programm mit der do-while Schleife zur Umwandlung einer gnzen positiven
Dezimalzahl in eine Dualzahl. Die Dualzahl soll in Tetraden (Vierergruppen) ausgeben werden.
Umwandlung einer Dezimalzahl in eine Binärzahl
Geben Sie die Dezimalzahl ein: 230
Die gesuchte Dualzahl lautet: 1110 0110

Programmieren mit C++

datadidact
1-36

2000-06

1 Grundlagen der Programmierung in C++
Weiterführende Aufgabe

C++ Programmierung

Zahlrate.cpp

(Mini-Projekt) Eine vom Rechner vorgegebene Zufallszahl soll durch Zahleneingabe erraten werden. Nach
Eingabe einer Ober- und Untergrenze erzeugt der Computer Zufallszahlen in diesem Bereich. Nach Eingabe
eines Zahlentipps erhält der Spieler eine Angabe, ob seine Zahl zu groß, zu klein oder richtig ist. Bei richtiger
Zahl wird die Anzahl der Versuche ausgegeben.
Erweiterungen:
1. Neues Spiel auf Anfrage
2. Abfrage auf sinnvolle Eingaben
3. Abbruch bei mehr als der maximalen Versuchsanzahl
4. Mehrere Spieler mit Punktekonto

L2

Probleme und deren Lösung

1. Vergessene geschweifte Klammern (syntaktischer Fehler)
Wenn der Fehler „do statement must have while“ erscheint, und man hat dem do aber ein passendes while()
zugedacht, dann sind meist fehlende (oder falsch gesetzte) geschweifte Klammern um den Schleifenkörper der
Fehler.
cin >> e;
i=0; s=0;
do,
s+=i; // Summieren
cout - << i++ << " " << endl;
,while (i<=e);

2. Endlosschleife (semantischer Fehler)
Auswirkung dieses Fehlers ist, dass eine Endlosschleife entsteht, so dass es den Eindruck macht, das
Programm „hänge“.
Die Ausgabe des untenstehenden Programmfragmentes wird immer einmal ausgeführt, wenn ein negatives e
eingegeben wird, ansonsten entsteht eine Endlosschleife. Bei negativem e wird die Schleife einmal mit
Ausgabe ausgeführt. Dann ist i>e und die Schleife wird beendet. Bei nichtnegativem e ist i<=e sofort erfüllt,
und da sich weder i noch e in der Schleife ändern, entsteht eine Endlosschleife.
cin >> e;
i=0; s=0;
do
{
s+=i; // Summieren
cout << i , << " " << endl;
}
while (i<=e);

Hier wurde also vergessen, i in der Schleife zu erhöhen, so dass es sich dem Endwert e nähert. Eine mögliche
Lösung:
do
{
s+=i; // Summieren
cout << i++ << " " << endl;
}
while (i<=e);

2000-06

datadidact
1-37

Programmieren mit C++

1 Grundlagen der Programmierung in C++

C++ Programmierung

L3

Schleife mit Anfangsabfrage

Bei der Schleife mit Anfangsabfrage, auch kopfgesteuerte Schleife genannt, kann es vorkommen, dass der
Schleifenkörper nie durchlaufen wird, weil die Schleifenbedingung schon zu Anfang nicht zutrifft. Solange die
Bedingung wahr ist, wird die Schleife durchlaufen.
Die Syntax in C++ lautet:
while (Bedingung) Anweisung;

Beispiel:
cout << "Ja oder Nein? ";
cin >> c;
while (c!='j' && c!='n')
{
cout << (char)7; // (char)7=ASCII-Zeichen
7=BELL; erzeugt Warnton
cin >>c;
}

Programmieren mit C++

datadidact
1-38

2000-06

1 Grundlagen der Programmierung in C++

Grundlegende Aufgabe

C++ Programmierung

Primzahl.cpp

Lassen Sie prüfen, ob eine long-Zahl Primzahl ist. Dividieren Sie die zu prüfende Zahl durch i=2, 3, usw. bis
i2>x ist und prüfen Sie, ob die Division x/i einen Rest läßt.
Grundlegende Aufgabe

SumX.cpp

Lassen Sie den Rechner die Summe der folgenden Zahlen bis zu einem Grenzwert g berechnen und geben Sie
die Anzahl der benötigten Glieder aus.
(SumA.cpp) 1 + 2 + 3 + 4 + ...+ n +...
(SumB.cpp) 1 - 2 + 3 - 4 + 5 ... + (2n-1) - 2n ...
(SumC.cpp) 1 + ½ + 1/3 + ...+ 1/n +...
(SumD.cpp) 1 - ½ + 1/3 ... + 1/(2n-1) - 1/(2n) ...
(SumE.cpp) 1 + 4 + 9 + 16 + 25 +...+ n2 +...
(SumF.cpp) 1 + 2 + 4 + 7 + 11 + 16 + ... + xn + (xn+n) + ...
Berechnung der Summe 1+2+3+4+... bis zu einem Grenzwert
Grenzwert: 16
Nach 6 Gliedern ist 16 erreicht. Die Summe ist 21.

Berechnung der Summe 1+2+3+4+... bis zu einem Grenzwert
Grenzwert: 28
Nach 7 Gliedern ist 28 erreicht. Die Summe ist 28.

Grundlegende Aufgabe

arithm1.cpp

Es sollen durch ein C++Programm alle Glieder einer arithmetischen Reihe erster Ordnung zwischen einem
Anfangsglied und einem Endglied ausgegeben werden. Die Differenz zwischen den Gliedern der Reihe soll als
variable Größe eingelesen werden.
Arithmetische Reihe.
Anfangsglied : 1
Endglied
: 101
Differenz
: 2
Reihe: 1, 3, 5, 7, ..., 101

Grundlegende Aufgabe

Werttab2.cpp

Im Programm Werttab1.cpp wird mit einer fußgesteuerten Schleife eine formatierte Wertetabelle der
Funktionsgleichung y = 0,1x³ - 2x² + 5 im Bereich -10 <= x <= 10 erstellt. Ändern Sie Werttab1.cpp so ab,
dass eine kopfgesteuerte Scheife benutzt wird. Lassen Sie die Anfangs- und Endwerte von x sowie eine
beliebige Schrittweite eingeben.

2000-06

datadidact
1-39

Programmieren mit C++

1 Grundlagen der Programmierung in C++

C++ Programmierung

Grundlegende Aufgabe

Euklid1.cpp

(Euklid1.cpp) Euklid kam auf die Idee, den größten gemeinsamen Teiler (ggT) z. B. von 322 und 63 so zu
berechnen: 322=5*63+7, dann 63=9*7+0 und dann zu beenden, da Rest =0. Ergänzen Sie das Programm:
// Programm euklid1.cpp ggT zweier Zahlen
... int a,b,rest;
cout << "Zwei Zahlen eingeben: ";
cin >> a >> b; //mit Leerstelle eingeben
while ...
rest = a % b; ...

Weiterführende Aufgabe

ProdAdd.cpp

(ProdAdd.cpp) Das Produkt zweier ganzer Zahlen ist mit Hilfe der Addition zu berechnen. Beachten Sie, dass
die Zahlen auch 0 oder negativ sein können.
Berechnung des Produktes ueber Addition
Multiplikator: 3
Multiplikand : 5
Das Produkt ist 15.

Berechnung des Produktes ueber Addition
Multiplikator 1: 0
Multiplikator 2: 5
Das Produkt ist 0.

Weiterführende Aufgabe

QuotSub.cpp

(QuotSub.cpp) Der ganzzahlige Quotient a/b zweier ganzer Zahlen a und b und der entstehende Rest sollen
über die Subtraktion berechnet werden. Überlegen Sie, welche Fehlerquellen es hier geben kann und
berücksichtigen Sie diese im Programm. Beispiel: 25 / 8 = 3 Rest 1

Programmieren mit C++

datadidact
1-40

2000-06

1 Grundlagen der Programmierung in C++

L4

C++ Programmierung

Probleme und deren Lösungen

Die hier geschilderten Probleme ähneln den bei der einfachen Auswahl aufgezeigten.
1. Strichpunkt nach while (semantischer Fehler)
Auswirkungen dieses Fehlers sind meist, dass
• der Schleifenkörper nur einmal ausgeführt wird, obwohl er öfter ausgeführt werden sollte.
• eine Endlosschleife entsteht, so dass es den Eindruck macht, das Programm „hänge“.
Der „Schleifenkörper“ des untenstehenden Programmfragmentes wird immer einmal ausgeführt, wenn ein
negatives e eingegeben wird, ansonsten entsteht eine Endlosschleife. Für den Compiler ist der Schleifenkörper
die leere Anweisung vor dem Strichpunkt. Der Block in {} wird daher nicht als Schleife, sondern als Sequenz
nach der Schleife ausgeführt. Bei negativem e wird dann die Schleife nie ausgeführt, weil sofort i>e ist. Bei
nichtnegativem e ist i<=e sofort erfüllt, und da sich weder i noch e in der leeren Schleife ändern, entsteht eine
Endlosschleife.
cin >> e;
i=0; s=0;
while (i<=e);,
{
s+=i; // Summieren
cout << i++ << " " << endl;
}

2. Vergessene geschweifte Klammern (semantischer Fehler)
Auswirkungen dieses Fehlers sind meist, dass
• der Schleifenkörper nur einmal ausgeführt wird, obwohl er öfter ausgeführt werden sollte.
• eine Endlosschleife entsteht, so dass es den Eindruck macht, das Programm „hänge“.
Die Ausgabe des untenstehenden Programmfragmentes wird immer einmal ausgeführt, wenn ein negatives e
eingegeben wird, ansonsten entsteht eine Endlosschleife. Für den Compiler ist der Schleifenkörper die
Anweisung s+=i. Die Ausgabe wird daher nicht in der Schleife, sondern als Sequenz hinter der Schleife
ausgeführt. Bei negativem e wird dann die Schleife nie ausgeführt und stattdessen sofort die Ausgabe, weil
sofort i>e ist. Bei nichtnegativem e ist i<=e sofort erfüllt, und da sich weder i noch e in der Schleife ändern,
entsteht eine Endlosschleife.
cin >> e;
i=0; s=0;
while (i<=e);,
s+=i; // Summieren
cout << i++ << " " << endl;
,

2000-06

datadidact
1-41

Programmieren mit C++

C++ Programmierung

L5

1 Grundlagen der Programmierung in C++

Die Zählschleife

Die Zählschleife ist eine Struktur, bei der von Anfang an feststeht, wie viele Wiederholungen ausgeführt
werden. Dabei wird noch ein Zähler (genannt Laufvariable) mitgeführt. Im Beispiel ändert sich die
Laufvariable von Anfangswert bis Endwert.

Die Syntax in C++ lautet:
for (Laufvariable=Anfangswert; Laufvariable<=Endwert; Laufvariable++) Anweisung;

Im einfachsten Fall wird die Laufvariable bei jedem Schleifendurchgang um 1 erhöht (inkrementiert). Man
spricht dann von einer Zählschleife mit der Schrittweite 1
Beispiele:
// gibt 20 Sterne in einer Zeile aus
for (i=1;i<=20;++i) cout << '*'; cout << endl;

// addiert 5 einzugebende Werte auf
cout << "5 Werte eingeben." << endl;
summe=0;
for (z=1; z<=5; z++)
{
cout << z << "-ter Wert: ";
cin >> x;
summe+=x;
}

Programmieren mit C++

datadidact
1-42

2000-06

1 Grundlagen der Programmierung in C++

C++ Programmierung

Jede Zählschleife kann durch eine Schleife mit Anfangsabfrage ersetzt werden:
for (Laufvariable=Anfangswert; Laufvariable<=Endwert; Laufvariable++)
Anweisung;
// ist das gleiche wie:
Laufvariable=Anfangswert;
while (Laufvariable<=Endwert)
{
Anweisung; Laufvariable++;
}

L6

Zählschleife mit variabler Schrittweite

Ersetzt man die Inkrementierung der Laufvariablen Laufvariable++ in den obigen Ausdrücken durch einen
anderen Inkrementierungsausdruck (z.B. Laufvariable+=5), dann ergibt sich eine Zählschleife mit variabler
Schrittweite.
Laufvariable=Anfangswert;
while (Laufvariable<=Endwert) { Anweisung; Laufvariable+=Weite; }
// ist das gleiche wie:
for (Laufvariable=Anfangswert; Laufvariable<=Endwert; Laufvariable+=Weite)
Anweisung;

Die folgende Anweisung bildet z.B. eine Schleife mit der Schrittweite 3 und setzt die Laufvariable i
nacheinander auf die Werte 1, 4, 7, 10:
for (i=1; i<=10; i+=3)
cout << "Wert der Laufvariable: " << i << endl;

2000-06

datadidact
1-43

Programmieren mit C++

C++ Programmierung

L7

1 Grundlagen der Programmierung in C++

Zählschleife mit lokal deklarierter Laufvariable

Meist ist es empfehlenswert, die Laufvariable von Zählschleife direkt im Schleifenkopf zu deklarieren. Dann
ist die Laufvariable nur innerhalb des Schleifenrumpfs gültig und es gibt keine Wechselwirkungen mit anderen
Variablen gleichen Namens.
Syntax:
for (typ Laufvar=Anfangsw; Laufvar<=Endwert; Laufvar+=Weite)
Anweisung;

Für das folgende Codefragment
int i = 0; // übergeordnet deklarierte Variable i
for (int i; i<=x; i++) // lokal deklarierte Variable i
{
// Anweisungen des Schleifenrumpfs
cout << i; // ändert sich bei jedem Schleifendurchlauf bis zu x+1
}
cout << i; // Das übergeordnete i behält seinen Wert

ist die übergeordnet deklarierte Variable i im gesamten Programm gültig, das den Schleifenrumpf umgibt. Im
Schleifenrumpf selbst gilt die lokal deklarierte Laufvariable i gleichen Namens – die übergeordnete Variable i
wird durch die Anweisungen im Schleifenrumpf nicht verändert.
Beispiel 1:
// Programm laufvar1.cpp
// Schleife mit global deklarierter Laufvariable
#include <iostream.h>
main() {
int i;
i = 5;
cout << "Anfangswert von i : " << i << endl;
for (i=1; i<=10; i++) cout << i << " ";
cout << "\nWeiterarbeiten mit i : " << i;
// schlecht, da verändert auf 11
}

Beispiel 2:
/Programm laufvar2.cpp
// Schleife mit lokal deklarierter Laufvariable
#include <iostream.h>
main() {
int i;
i = 5;
cout << "Anfangswert von i : " << i << endl;;
for (int i=1; i<=10; i++) cout << i << " ";
// hier i neu lokal deklariert
cout << "\nWeiterarbeiten mit i : " << i;
// i wird mit 5 weiterverarbeitet
}

Programmieren mit C++

datadidact
1-44

2000-06

1 Grundlagen der Programmierung in C++

Grundlegende Aufgabe

C++ Programmierung

Ueb0x.cpp

Erstellen Sie mittels Zählschleifen die folgenden Programme:
a) (Ueb01.cpp) Die Variable x soll von 1 bis 10 laufen und immer um 1 erhöht werden. Dabei soll der
aktuelle Zählerstand ausgegeben werden.
b) (Ueb02.cpp) Die Variable x soll von 30 bis 10 laufen und immer um 2 erniedrigt werden. Dabei soll der
aktuelle Zählerstand ausgegeben werden.
c) (Ueb03.cpp) Die Variable x soll von einem Anfangswert bis zu einem Endwert laufen und immer um
0,5 erhöht werden. Dabei soll der aktuelle Zählerstand ausgegeben werden.
d) (Ueb04.cpp) Erstellen Sie eine äußere Zählschleife mit der Variablen k, die von 1 bis 10 zählt und eine
innere Schleife i, die von 1 bis 3 zählt.
Ueb4.cpp
1
123
2
123
...
10
123

Grundlegende Aufgabe

ProdAdd2.cpp

Das Produkt zweier ganzer Zahlen ist mit Hilfe der Addition zu berechnen. Beachten Sie, dass die Zahlen auch
0 oder negativ sein können.
Grundlegende Aufgabe

Einmal1.cpp

Ergänzen Sie das folgende Programm, welches das kleine Einmaleins in tabellarischer Form erzeugt:
...
int x,y;
for (x=1; x<10; x++)
// äußere Schleife
{
for (y ... )
// innere Schleife
cout << x << "*" << y << "=" << x*y << endl;
cout << endl;
}
...

Grundlegende Aufgabe

Ungerade.cpp

Lassen Sie den Computer die ungerade Zahlen zwischen zwei einzugebenden Werten ausdrucken.
Grundlegende Aufgabe

Rechnen.cpp

Es sollen die Quadratzahlen, die Kubikzahlen und die Kehrwerte der Zahlen zwischen zwei einzugebenden
Grenzen ausgegeben werden.

2000-06

datadidact
1-45

Programmieren mit C++

C++ Programmierung

Grundlegende Aufgabe

1 Grundlagen der Programmierung in C++

SumNx.cpp

Schreiben Sie Programme, die nach Eingabe von n die folgenden Summen berechnen:
a)
b)
c)
d)

(SumNa.cpp) 12 + 22 + 32 + 42 + ... + n2
(SumNb.cpp) 12 + 32 + 52 + ... + (2 n - 1)2
(SumNc.cpp) 22 + 42 + 62 + ... + (2 n)2
(SumNd.cpp) 1 + 1 / 2 + 1 / 3 + ... + 1 / n

Grundlegende Aufgabe

Primzahl2.cpp

Verändern Sie Primzahl.cpp, so dass es alle Primzahlen ab 2 bis zu einer einzugebenden Obergrenze
berechnet.
Weiterführende Aufgabe

N3und5.cpp

Der Rechner soll alle natürlichen Zahlen zwischen einzugebenden Grenzen ausgeben, die sowohl durch 3 als
auch durch 5 teilbar sind.
Weiterführende Aufgabe

N3oder5.cpp

Der Rechner soll alle natürlichen Zahlen zwischen einzugebenden Grenzen ausgeben, die durch 3 oder durch 5
teilbar sind.
Weiterführende Aufgabe

N4und7.cpp

Der Rechner soll alle natürlichen Zahlen zwischen einzugebenden Grenzen ausgeben, die sowohl durch 4 als
auch durch 7 teilbar sind.
Weiterführende Aufgabe

N4oder7.cpp

Der Rechner soll alle natürlichen Zahlen zwischen einzugebenden Grenzen ausgeben, die durch 4 oder durch 7
teilbar sind.
Weiterführende Aufgabe

Kapital.cpp

Ein Kapital k wird n Jahre lang mit Zinseszins verzinst. Lassen Sie ein Tabelle ausgeben, die den Betrag
ausgibt, der am Ende jeden Jahres auf dem Konto steht. Der Zinsfuß p, das Kapital k und die Anzahl der Jahre
n sollen einzugeben sein. (b = k ( 1 + p / 100)n)

Programmieren mit C++

datadidact
1-46

2000-06

1 Grundlagen der Programmierung in C++

Weiterführende Aufgabe

C++ Programmierung

Reis.cpp

Der indische König Schehram verlangte, dass Sessa, der Erfinder des Schachspiels, sich eine Belohnung
wählen solle. Dieser erbat sich die Summe Weizenkörner, die sich ergibt, wenn für das 1. Feld des
Schachbrettes 1 Korn, für das 2. Feld 2 Körner für das 3. Feld 4 Körner usw. gerechnet werden.
Schreiben Sie ein Programm, das für alle 64 Felder die Gesamtsumme der Körner berechnet. Geben Sie auch
das Gewicht der Körner an, wenn 200 Körner 1g wiegen.
Wie viele Eisenbahnwaggons bräuchte man zum Transport des Reises und wie lange wäre der Zug, wenn ein
Eisenbahnwaggon 30t fasst und 15m lang ist?
Weiterführende Aufgabe

FiFolge1.cpp

Leiten Sie aus folgendem Ausführungsbeispiel zum Programm FiFolge1.cpp
das Bildungsgesetz der
FIBONACCI-Folge ab und entwickeln Sie das Programm mit Zählschleife. Verwenden Sie die Variablen f1
und f2 als Startwerte, f3 für das jeweils nächste Folgeglied.
Wieviele Folgeglieder der Fibonacci-Folge sollen berechnet werden? 14
Geben Sie zwei Startwerte ein: 2 3
5
8
13
21
34
55
89
144
233
377
610
2584

Weiterführende Aufgabe

987

1597

DesignX.cpp

Erstellen Sie die folgenden Programme mit geschachtelten for-Schleifen und den Zählervariablen z und s:
=
= = = = =
= =
=
=
= = =
=
=
= = = =
=
=
= = = = =
= = = = =
Ende design1.cpp Ende design2.cpp

2000-06

= = = =
= = =
= =
=

= = = = =
= = = =
= = =
= =
=
Ende design3.cpp

datadidact
1-47

Programmieren mit C++

C++ Programmierung

L8

1 Grundlagen der Programmierung in C++

Anweisungen für Schleifenabbruch und -wiederholung

Zwei zusätzliche Anweisungen können in einigen Fällen die Übersicht bei der
Programmierung von Schleifen erhöhen, aber auch stark beeinträchtigen. Die
Anweisungen sollten daher sparsam und nach reiflicher Überlegung eingesetzt
werden (möglichst nur einmal pro Schleife). Bei Vertretern der „reinen Lehre“
der strukturierten Programmierung gelten derartige Anweisungen als
„unstrukturiert“.
• break;
Die Schleife wird sofort verlassen (beendet).
• continue;
Die Schleifenbedingung wird sofort erneut abgefragt.
Die Anweisungen break und continue können bei allen Schleifenformen
eingesetzt werden. Für break existiert eine eigene Darstellung im Struktogramm,
die rechts dargestellt ist.
// Verwendung von break:
do
{
cout << "Ja oder Nein? ";
cin >> c;
if (c==’J’ || c==’j’ || c==’N’ || c==’n’) { break; }
cout << "Ungültige Eingabe!" << endl;
}
while (true);

// Verwendung von continue:
bool ok;
do
{
cout << "Ja oder Nein? ";
cin >> c;
ok = (c=='J' || c=='j' || c=='N' || c=='n');
if (!ok) continue; // Dann nochmal Ja oder Nein abfragen
// Hier würde nun ein längerer Verarbeitungsteil folgen,
// der nur abgearbeitet wird, wenn Ja oder Nein eingegeben wird.
}
while (false);

Für die Verwendung der continue-Anweisung gibt es keine gesonderte Struktogrammdarstellung. Man kann
jedoch die folgende Ersetzung verwenden:
Programmieren mit C++
2000-06
datadidact
1-48

1 Grundlagen der Programmierung in C++
// Schleife mit continue
while (Bedingung1)
{
Anweisung1;
if (Bedingung2) continue;
Anweisung2;
Anweisung3; // usw.
}

C++ Programmierung

// entspricht Schleife mit Auswahl
while (Bedingung1)
{
Anweisung1;
if (!Bedingung2)
{
Anweisung2;
Anweisung3; // usw.
}
}

Entwerfen Sie die folgenden Programme jeweils ohne Verwendung von break oder continue und dann
verändern Sie sie, so dass break oder continue zum Einsatz kommen.
Grundlegende Aufgabe

AddBel.cpp

Schreiben Sie ein Programm, das eine beliebige Anzahl von einzugebenden Zahlen addiert, bis die Zahl 0
eingegeben wird.
Addition von Zahlen
Nach der letzten Zahl 0 eingeben
1. Zahl: 15.2
2. Zahl: 17.1
3. Zahl: 20
4. Zahl: 0
Die Summe der 3 eingegebenen Zahlen ist 52.3.
Programmende.

Grundlegende Aufgabe

DivBel.cpp

Schreiben Sie ein Programm, das eine beliebige Anzahl von einzugebenden Zahlenpaaren dividiert, bis als
erste Zahl 0 eingegeben wird. Wird als zweite Zahl 0 eingegeben, soll die Eingabe wiederholt werden.
Division von Zahlen
Nach der letzten Zahl 0 eingeben
1. Zahl: 15.2
2. Zahl: 17.1
15.2/17.1 ist 0.8888888888889.
1. Zahl: 20
2. Zahl: 0
Durch 0 kann nicht dividiert werden.
1. Zahl: 0
Programmende.

1.6 Modul (Unterprogramm, Funktion)
Wenn die zu bearbeitenden Algorithmen so groß werden, dass man sie durch ein
übersichtliches Struktogramm nicht mehr darstellen kann, muss man die Aufgabenstellung
modularisieren. Das bedeutet, ein Problem wird in Teilprobleme zerlegt, die einzeln für
sich gelöst werden.
Jede strukturierte Programmiersprache besitzt Sprachelemente zur Modularisierung. In
C++ heißen die Module Funktionen. Bislang enthielten unsere C++-Programme schon ein
einziges Modul, nämlich das Hauptprogramm main(). Bereits an void main() erkennen
wir, dass eine Funktion einen Typ hat, einen Bezeichner und einen Anweisungsblock, der
zwischen geschweiften Klammern „{“ und „}“ eingeschlossen wird. Allgemein wird eine
Funktion deklariert als
Rückgabetyp Funktionsname (Parameterliste)

2000-06

datadidact
1-49

Programmieren mit C++


Related documents


grundlagenc
obungsklausur probeklausur
methodenblatt
handreichungen f r den notfall
sudokuanleitung3
hamburg hochzeitslocation1757


Related keywords