MezData-Logo Creative Commons License 313 Lösungen Button :CPP: Das EVA-Prinzip

Problem: Erstelle ein Programm, das eine eingegebene Zahl mit 2 multipliziert ausgibt.

Wie kann man den Programmablauf gliedern und die notwendigen Verarbeitungsschritte übersichtlich aufschreiben?

Struktogramm
darstellung

Eingabe eingabe
ausgabe <- 2 * eingabe
Ausgabe ausgabe

EVA -Prinzip

Eingabe Eingabe eingabe
Verarbeitung ausgabe <- 2 * eingabe
Ausgabe Ausgabe ausgabe

Bisher haben wir uns nur mit der Ausgabe von Texten auf der Konsole beschäftigt, um dieses Problem zu lösen, müssen wir einen Wert von der Konsole einlesen:

Eingabe: Einlesen eines Wertes von der Konsole

Einen Wert von der Konsole einzulesen ist genau so einfach wie die Ausgabe:

cin >> eingabe; // Console In, Wert einlesen und in eingabe merken

Wenn man einfach diese Anweisung schreibt, wird der Compiler einen Fehler ausgeben: "eingabe" ist nicht definiert!

Welche Schritte sind notwendig, damit eine Zahl im Programm gemerkt (gespeichert) werden kann?

Variablen

Man stelle sich vor, der Speicher des Computers sei ein Einsortierungskasten:

Aufgabe: Hier hast du 2 Euro, lege den Wert in das Fach mit deinem Namen! In diesem Beispiel heisst du Erna.

Was muss getan werden?

Definition einer Variable (Veränderbaren)

Das Fach muss erst beschriftet und angelegt werden, das nennt man definieren:

int erna; // Definition von erna

Der Wert 2 wird in das Fach gelegt, zugewiesen:

erna = 2;  // erna den Wert 2 zuweisen

Einer Variablen einen Startwert zuweisen nennt man auch initialisieren.

Der Wert von erna ist nun 2, erna hat den Wert 2, der Wert 2 wurde in der Variablen erna gespeichert.

Wie kann der Wert einer Variablen wieder ausgelesen werden?

Einfach Variable aufrufen:

cout << erna; // den Wert von erna ausgeben

Job: Erstelle ein Projekt mit dem Namen eva-prinzip, dessen main-Funktion folgende Anweisungen enthält:

int erna;  // Definieren von erna
erna = 2;  // erna den Wert 2 zuweisen
cout << "Erna hat " << erna << " Euro" << endl;  // den Wert von erna ausgeben

Variablen-Typen

Ismael ist ein ganz Genauer, deshalb schleppt er auch immer seinen Taschenrechner mit sich rum, er will nun ein Fach für seinen Taschenrechner im Speicher!

Passt so ein Taschenrechner in ein Euro-Fach wie es Erna hat?

Für Ismael muss also ein anderer Typ Fach definiert werden, ein Typ für grosse und genaue Werte (double):

double ismael; // Definition von ismael

Ismael hat auch nicht einfach einen Taschenrechner sondern genau 1.0 Taschenrechner gelle!

ismael = 1.0; // ismael den Wert 1.0 zuweisen

Der Wert der Variablen wird allerdings genauso einfach wie bei Erna ausgegeben:

cout << ismael; // den Wert von ismael ausgeben

Job: Erweitere das Projekt für Ismael:

double ismael; // Definition von ismael
ismael = 1.0; // ismael den Wert 1.0 zuweisen
cout << "Ismael hat genau " << ismael << "Taschenrechner" << endl; // den Wert von ismael ausgeben

Für verschiedene Typen von Daten braucht man verschieden grosse Fächer, d.h. verschieden viel Speicher, bei der Definition muss also gleich bekannt gegeben werden welchen Typ die Variable hat, damit der Compiler weis wieviel Speicher er reservieren soll.

Woher weis der Compiler beim Ausgeben das Ismael ein ganz Genauer ist?

Durch die Typangabe bei der Definition weis der Compiler ausserdem wie der Wert in dem Fach zu interpretieren ist, bei einem double-Fach sollen auch die Nachkommastellen ausgegeben werden.

Siehe Darstellungen von Daten in digitalen Systemen...

Allgemeine Form einer Definition

<Typ> <Bezeichner>;

Definitionen bestehen aus einer Typangabe und einem Bezeichner (engl. Identifier).
Der Identifier ist das "Namensschild" des Fachs.

Initialisierung von Variablen

Welchen Wert hat eigentlich ein Fach dem noch nichts zugewiesen wurde?

Man stelle sich vor, das Fach wurde definiert aber es wurde noch kein Wert zugewiesen, was da wohl drin ist?

Job: Kommentiere die Zuweisungen der Werte von erna und ismael im Projekt aus, welche Werte werden ausgegeben?

Erkenntnis: Beim Definieren werden die Fächer in C nicht automatisch ausgeräumt und leer gemacht, da ist eventuell noch das Zeugs vom Vorbesitzer drin!

Gleich einen Startwert zuweisen!

Da in dem Fach alles Mögliche sein kann ist es sinnvoll gleich bei der Definition einen Wert zuzuweisen, das nennt man initialisieren (Startwert zuweisen):

int erna = 2; // Definition und Initialiesierung von erna mit 2
double ismael = 1.0; // Definition und Initialisierung von ismael mit 1.0

Allgemeine Form der Definition mit Initialiserung

<Typ> <Bezeichner> = <Initialwert>;

Ordnung ist das halbe Leben, zuerst die Variablen dann der Rest!

C und Java erlauben auch mitten zwischen Anweisungen neue Variablen einzuführen, zu definieren. In Pascal oder Delphi würde das eine Fehlermeldung ergeben, denn dort gilt:

Variablen müssen in Pascal und Delphi am Anfang definiert werden!

Es ist daher empfehlenswert und guter Stil die verwendeten Variablen am Anfang zu definieren und gleich zu initialisieren.
Tückischerweise gehen unterschiedliche Programmiersprachen auch unterschiedlich mit diesem Thema um -eine prima Ursache von Fehlern und stundenlanger Fehlersuche...
In Delphi werden z.B. frisch definierte Variablen automatisch mit 0 initialisiert, blöd wenn man sich daran gewöhnt hat und dann C++ schreiben soll... ;-)

Variablen sollten in C und Java am Anfang definiert werden!

Info: Der Ort, an dem eine Variable definiert wird bestimmt ausserdem den Kontext, ihren Gültigkeitsbereich, dazu mehr bei Funktionen, Klassen und Methoden..

Verarbeitung: Die "ausgabe" berechnen

Wir können nun die Variable "eingabe" definieren, einen Wert von der Konsole einlesen und der Variablen "eingabe" zuführen:

int eingabe; // Definition von eingabe
cin >> eingabe; // Wert von Konsole einlesen und in eingabe speichern

Aus dem Wert in eingabe soll nun der Ausgabewert berechnet werden, dazu brauchen wir noch eine Variable ausgabe:

int eingabe, ausgabe; // Definition von eingabe und ausgabe
cin >> eingabe; // Wert von Konsole einlesen und in eingabe speichern

Betrachten wir die Anweisung für die Berechnung der Ausgabe:

Anweisung (Instruction)

Eine Anweisung (wird auch Befehl genannt) ist ein einzelner Arbeitsschritt (Beispiele unten) oder eine gesteuerte Folge von Arbeitsschritten (kommt noch)

Im Struktogramm In C Beschreibung
ausgabe <- 2 * eingabe
ausgabe = 2 * eingabe;
Der Wert des Ausdrucks "2 * eingabe" wird ausgabe zugewiesen
ausgabe <- eingabe * 4 + 3
ausgabe = eingabe * 4 + 3;
Der Wert des Ausdrucks "eingabe * 4 + 3" wird ausgabe zugewiesen

Wert zuweisen (<-) bedeutet, der Wert wird abgespeichert, in die Variable geschrieben, in Java und C verwendet man für die Zuweisung das "=".

Wichtig: Einzelne Anweisungen müssen in Java und C immer mit einem ";" Semikolon abgeschlossen werden!

Hinweis: Ein- und Ausgabe werden auch als Anweisungen bezeichnet!

Info: In Pascal und Delphi wird für die Zuweisung ":=" verwendet.

Ausdruck (Expression)

Ein Ausdruck ist eine Berechnungsvorschrift für einen Wert: 2 * eingabe; 3 + 4
Einen Ausdruck auswerten heisst seinen Wert ermitteln.

Reihenfolge der Anweisungsbearbeitung

Die Anweisungen werden in der Reihenfolge ihres Vorkommens im Quelltext bearbeitet, d.h. folgender Quelltext macht wenig Sinn:

int eingabe, ausgabe; // Definition von eingabe und ausgabe
ausgabe = 2* eingabe; 
cin >> eingabe;
cout << ausgabe;

Job: Implementieren Sie die Lösung für das Leitproblem, fordern Sie den Benutzer zur Eingabe eines Wertes auf.

nicht fertigDefinition von Var: immer klein schreiben, Auflösung, Bsp. Gif mit unterschiedlichen Farbtiefen, Formatieren von Quelltext

Wiederholungsfragen

FrageBeschreiben Sie das EVA-Prinzip.

FrageErklären Sie wozu man Variablen definiert.

FrageWas versteht man unter einer Variablen-Definition, erläutern Sie anhand eines Beispiels zusätzlich die Begriffe Variablen-Typ und Identifier (Bezeichner).

FrageWas versteht man unter Initialisierung?

FrageErläutern Sie den Unterschied zwischen Anweisung und Ausdruck.