close

Anmelden

Neues Passwort anfordern?

Anmeldung mit OpenID

Dreamdays - Geist und Sendung

EinbettenHerunterladen
FH D
FB 4
Fachhochschule Düsseldorf
Fachbereich Maschinenbau
University of Applied Sciences
und Verfahrenstechnik
Informatik I Praktikum - Modul 1
3
Modul 1 - Kommandozeilen-Programm mit Aus- und Eingabe ........................................... 5
3.1
Einführung ........................................................................................................................................ 5
3.2
Das „Hello world“-Programm.................................................................................................... 6
3.3
Web-basierte Programmierübungen mit dem „Onlinecompiler“ ............................... 7
3.3.1
3.4
Arbeiten mit dem Format-String der printf Funktion ..................................................... 8
3.4.1
3.5
Übung 4: Zeichen-Eingabe und „Rechnen mit Zeichen“ ...................................... 11
Rechnen mit Programmvariablen ........................................................................................ 12
3.7.1
3.8
Übung 3: Werte von Variablen ausgeben.................................................................. 10
Zeichen-Eingabe und Zahlen-Eingabe mit der Funktion getchar............................. 10
3.6.1
3.7
Übung 2: Mehrzeiligen Text ausgeben und Formatelemente anwenden ........ 9
Ausgabe des Inhalts von Programmvariablen .................................................................... 9
3.5.1
3.6
Übung 1: Übersetzen und Ausführen des „Hello world“-Programms............... 7
Übung 5: Wertzuweisung an eine Variable und Integer-Arithmetik ............. 12
Was Sie aus Modul 1 mitnehmen sollen............................................................................. 13
Lehr- und Forschungsgebiet Informatik
Stand: 23. Oktober 2014
3 Modul 1 - Kommandozeilen-Programm mit Aus- und Eingabe
3 Modul 1 - Kommandozeilen-Programm mit Aus- und Eingabe
3.1
Einführung
Ein "Kommandozeilen-Programm" benötigt keine grafische Benutzeroberfläche. Es wird
durch ein Kommando in einem Textfenster des Betriebssystems gestartet. Unter LinuxBetriebssystemen und Mac OS X kann ein Terminalfenster (auch "Shell-Fenster"
genannt) geöffnet werden. Unter Windows-Betriebssystemen öffnet man das
Terminalfenster im Startmenü durch den Befehl "cmd" im Menüpunkt "Ausführen". Unter
grafischen Benutzeroberflächen kann ein Kommandozeilen-Programm auch durch
Doppelklicken auf die Programmdatei gestartet werden.
Die Eingaben und die Ausgaben von Kommandozeilen-Programmen sind Textzeichen, die
i.d.R. direkt in dem Terminalfenster mit Hilfe der Tastatur eingegeben werden bzw. dort
angezeigt werden. Textzeichen werden in der Programmierung mit Hilfe von
Zeichentabellen dargestellt, die jedem Zeichen einen Zahlenwert zuordnen. Die
Standard-Zeichentabelle für einfache Ein- und Ausgaben ist die sogenannte ASCII-Tabelle
siehe z.B.: http://de.wikipedia.org/wiki/ASCII.
Das Leerzeichen (SP, engl. space oder blank), zum Beispiel, hat den hexadezimalen
Zahlencode 0x20. Das Zeichen 0 wird mit der Hexadezimalzahl 0x30 dargestellt, was dem
Dezimalwert 48 entspricht (3*16 + 0 == 4*10 + 8). Das Zeichen A hat den Dezimalwert 65
(4*16 + 1).
5
3 Modul 1 - Kommandozeilen-Programm mit Aus- und Eingabe
Die vorstehende Skizze verdeutlicht, wie ein Kommandozeilen-Programm mit seiner
Umgebung kommuniziert. Alle auf der Tastatur eingegebenen Zeichen werden über den
Kanal der Standard-Eingabe (Name im C-Programm: stdin) der Reihe nach dem
Programm zugeleitet. Das Programm kann diese Eingaben "einlesen". Ein Programm kann
selbstverständlich auch Zeichen bzw. Texte "ausgeben". Diese Zeichen werden
normalerweise über den Kanal der Standard-Ausgabe (Name im C-Programm: stdout)
in dem Terminalfenster angezeigt. "stderr" ist ein alternativer Ausgabekanal, der in
diesem Praktikum nicht verwendet wird.
In diesem Praktikumsmodul sollen Sie lernen, ein Kommandozeilen-Programm mit
einfachen Ein- und Ausgaben in der Programmiersprache C zu programmieren.
3.2
Das „Hello world“-Programm
#include <stdio.h>
/* wird für printf gebraucht */
int main (void) /* Dies ist ein Programm ohne Dateneingabe*/
{
printf("Hello world!"); /*Aufruf der Funktion printf*/
return 0; /* hier wird das Programm beendet */
}
Das sogenannte "Hello world"-Programm ist das Standardbeispiel für ein Programm
minimaler Größe. Es besteht aus zwei Anweisungen, die jeweils von einem Semikolon
(;) abgeschlossen werden. Dieses Programm liest keine Daten-Eingabe und erzeugt
lediglich eine Zeile Ausgabetext.
Der Ausgabetext "Hello world!" wird von der Funktion printf erzeugt und als
Folge einzelner Zeichen ('H', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd', '!')
zum Standard-Ausgabe-Kanal geschickt. Alle anderen Programmzeilen, von #include
bis }, bilden den Programmrahmen, der in diesem Praktikumsmodul für alle
6
3 Modul 1 - Kommandozeilen-Programm mit Aus- und Eingabe
Übungsprogramme verwendet werden soll. Der gesamte auszuführende Programmcode,
also die Anweisungen, die der Prozessor ausführen soll, stehen zwischen den beiden
geschweiften Klammern { }. Text der durch /* und */ eingeschlossen ist, wird als
Kommentar, ohne Auswirkung auf die Programmausführung, behandelt.
Der Ausgabetext ist im Aufruf der Funktion printf von doppelten geraden
Anführungszeichen (engl.: quotation mark, ") umschlossen. Diese beiden Zeichen
markieren Anfang bzw. Ende der Zeichenkette (engl.: string). Sie gehören nicht zu den
Zeichen, die ausgegeben werden!
3.3
Web-basierte Programmierübungen mit dem „Onlinecompiler“
Für die ersten Programmierübungen verwenden wir ein web-basiertes
Programmierwerkzeug.
Im
Unterschied
zu
einer
richtigen
ProgrammEntwicklungsumgebung (oft IDE genannt, für engl.: integrated development environment)
kann mit dem "Onlinecompiler" kein ausführbares Programm auf dem eigenen Rechner
erstellt werden.
Bei dem web-basiertes Programmierwerkzeug wird auf einer Webseite der CProgrammcode in ein Textfeld geschrieben. Außerdem gibt es ein separates Textfeld für
die Benutzer-Eingaben, die das Programm bei seiner Ausführung normalerweise direkt
von der Tastatur lesen würde. Nach dem Abschicken des Webformulars wird der
Programmcode auf dem Server zunächst darauf überprüft, ob die Syntax
("Rechtschreibung") korrekt ist. Wenn der Programmcode Syntaxfehler enthält werden
entsprechende Fehlermeldungen angezeigt. Falls das Programm übersetzt (compiliert)
und ausgeführt werden kann, dann werden eventuelle Programmausgaben auf der
Webseite des Onlinecompilers angezeigt.
3.3.1 Übung 1: Übersetzen und Ausführen des „Hello world“-Programms
Gehen Sie auf die Webseite
http://C.mv.fh-duesseldorf.de/ (oder kurz: cvis.de)
Geben Sie dort das "Hello world"-Programm ein. Die Kommentare /* ... */ können Sie alle
oder auch nur einige weglassen, wie Sie möchten.
 Schicken Sie dann das Webformular mit dem Programm durch Drücken der
Schaltfläche ab.
 Kontrollieren Sie die Ausgabe des Programms.
Wird exakt der Text (die Zeichenkette) ausgeben, den (die) Sie mit dem printf
Funktionsaufruf programmiert haben?
7
3 Modul 1 - Kommandozeilen-Programm mit Aus- und Eingabe
3.4

Für die Ausgabe eines einzelnen Zeichens kann man alternativ zur Funktion
printf die Funktion putchar verwenden. Mit der Programmzeile
putchar('!');
wird ein einzelnes Ausrufezeichen ausgeben. Verändern Sie das Programm so dass
"Hello world" von der Funktion printf und das Ausrufezeichen anschließend
von der Funktion putchar ausgegeben wird.

Variieren Sie den Text und produzieren Sie damit andere Ausgaben,
wie z.B. Hallo Welt?. Vergewissern Sie sich, dass immer genau die Zeichenkette
ausgegeben wird, die Sie mit Ihrem Programm tatsächlich ausgeben wollen.
Arbeiten mit dem Format-String der printf Funktion
Der erste Parameter der printf Funktion, der Textteil zwischen der runden Klammer
auf und dem ersten Komma, ist eine Zeichenkette ("...") und wird Format-String genannt.
In der 1. Übung haben Sie gesehen, dass der Text in dieser Zeichenkette, in diesem Fall
"Hello world!", von printf auf dem Bildschirm ausgegeben wird (Standard-AusgabeKanal).
Der Format-String kann auch Sonderzeichen enthalten, die anders als normaler Text,
nicht direkt ausgegeben werden, sondern eine spezielle "Anweisung" für die Funktion
printf darstellen.
Das Beispiel printf("Hello world%c \n %i", '!', 2013) enthält drei spezielle
"Anweisungen":
 %c ist ein Formatelement, das einen Platzhalter für ein einzelnes Zeichen darstellt
(character ist das englische Wort für Zeichen). Das tatsächlich auszugebene
Zeichen an dieser Stelle wird als ein weiterer Parameter der Funktion printf
übergeben (hier das Ausrufezeichen umschlossen von zwei einfachen
Anführungszeichen '!').
 %i ist ein Formatelement, das einen Platzhalter für eine ganze Zahl darstellt
(integer bedeutet im Englischen "ganze Zahl").
8
3 Modul 1 - Kommandozeilen-Programm mit Aus- und Eingabe
 \n steht für das "neue Zeile Zeichen" (engl.: newline). Es bewirkt, dass das nächste
Zeichen in einer neuen Zeile auf dem Bildschirm ausgegeben wird. \n besteht aus
zwei Zeichen, dem umgekehrten Schrägstrich und dem Kleinbuchstaben n. In der
Ausgabe erzeugt diese Zeichenkombination aber ein einzelnes Sonderzeichen,
nämlich das Newline-Zeichen.
3.4.1 Übung 2: Mehrzeiligen Text ausgeben und Formatelemente anwenden




3.5
Lassen Sie das Programmbeispiel aus diesem Abschnitt übersetzen und ausführen.
Analysieren Sie die Ausgaben des Programms genau. Können Sie jedes einzelne
Zeichen und die Zeilenumbrüche in der Ausgabe nachvollziehen?
Fügen Sie Ihren Vornamen in den Format-String ein, ersetzen Sie die Jahreszahl
durch Ihre Matrikelnummer und ändern Sie das Ausrufezeichen in ein Semikolon.
Außerdem sorgen Sie dafür, dass die Ausgabe jetzt aus insgesamt 3 Zeilen besteht.
Bitte durch Übersetzen und Ausführen testen!
Fügen Sie %s als ein weiteres Formatelement hinter Ihrem Vornamen in den
Format-String ein. %s ist ein Platzhalter für eine Zeichenkette. Ergänzen Sie nun
die Parameterliste der printf Funktion, so dass in der Ausgabe hinter Ihrem
Vornamen der Nachname erscheint. Erinnerung: Zeichenketten (strings) werden
von doppelten geraden Anführungszeichen (") eingeschlossen.
Ausgabe des Inhalts von Programmvariablen
#include <stdio.h>
int main (void)
{
int ganze_zahl= 65; /*hier wird eine int-Variable
definiert*/
char zeichen1= '!'; /* zeichen1 ist eine char-Variable */
printf("Wert der Integer-Variablen: %i ", ganze_zahl);
putchar(zeichen1);
return 0;
}
Das vorstehende Programmbeispiel enthält die Definition zweier Variablen. Variable in
Programmiersprachen sind Speicherplätze, denen man einen jeweils eindeutigen Namen
gibt. Variable können mit Werten beschrieben werden damit man diese Werte später im
Programm wieder auslesen und verwenden kann. Der Datentyp der Variablen
ganze_zahl ist int (integer ist die englische Bezeichnung einer ganzen Zahl). Die
Variable ist dadurch eine Speicherstelle für einen ganzzahligen Wert. In dem gezeigten
Beispiel wurde der Variablen mit dem Namen ganze_zahl der Anfangswert 65
9
3 Modul 1 - Kommandozeilen-Programm mit Aus- und Eingabe
zugewiesen. Der Datentyp der Variablen zeichen1 ist char (character ist das englische
Wort für Zeichen).
Mit der printf Funktion kann man den Inhalt von Variablen formatiert ausgeben. Dazu
muss im Ausgabetext (Format-String) ein Formatelement für den jeweiligen Wert
eingefügt werden. Das Formatelement für Integer-Werte ist %i. Die Variable selbst muss
der Funktion printf als Parameter übergeben werden.
3.5.1 Übung 3: Werte von Variablen ausgeben
3.6



Lassen Sie das Programmbeispiel aus diesem Abschnitt übersetzen und ausführen.
Gibt Ihr Programm genau die Textzeile "Wert der Integer-Variablen: 65 !" aus?
Definieren Sie eine zusätzliche Variable mit dem Datentyp char (den VariablenNamen wählen Sie selbst, z. B. "neue_zeile"). Dieser Variablen soll der Anfangswert
'\n' zugewiesen werden. Konstante Werte vom Typ char werden immer mit
zwei einfachen Anführungszeichen (engl.: apostrophe, ') eingeschlossen.

Setzen Sie das Formatelement %c in den Format-String ein, und zwar hinter den
Doppelpunkt. Setzen Sie außerdem die neue char-Variable (den von Ihnen
gewählten Namen) in die Parameterliste der Funktion printf ein (richtige
Reihenfolge beachten!). Welchen Effekt haben diese Änderungen auf die
Programm-Ausgabe?
Zeichen-Eingabe und Zahlen-Eingabe mit der Funktion getchar
#include <stdio.h>
int main (void)
{
int ganze_zahl;
/*int-Variable ohne Anfangswert*/
char zeichen1, zeichen2; /* zwei char-Variable ohne Anfangswert
*/
zeichen1 = getchar(); /*lese das erste Zeichen von der Tastatur*/
zeichen2 = getchar(); /*lese das zweite Zeichen von der Tastatur*/
printf("Eingelesene Zeichen:\n");
putchar(zeichen1); putchar(zeichen2); /*Eingabezeichen wieder
ausgeben*/
/* Versuche die Zeichen in eine Zahl umzuwandeln */
ganze_zahl = (zeichen1 - '0') * 10 + (zeichen2 - '0');
printf("\nDezimalzahl aus zwei Zeichen: %i", ganze_zahl);
return 0;
}
Die Funktion getchar holt das jeweils nächste Zeichen aus dem Standard-EingabeKanal. Bei jedem Aufruf bekommt der Ausdruck getchar() den Wert des jeweils
10
3 Modul 1 - Kommandozeilen-Programm mit Aus- und Eingabe
nächsten Zeichens. Oder anders ausgedrückt: Die Funktion getchar liefert bei ihrem
Aufruf das jeweils nächste Zeichen als Rückgabewert.
Das Gleichheitszeichen = ist in der Programmiersprache C ein Operator (der
Zuweisungsoperator), der den Wert auf seiner rechten Seite in die Variable auf seiner
linken Seite schreibt. Der Wert von getchar wird mit dem Zuweisungsoperator in die
Variable zeichen1 bzw. zeichen2 geschrieben.
Die Differenz von zwei Zeichen ist deren Abstand in der ASCII-Tabelle. Zum Beispiel
haben die Differenzen '1' – '0' und 'b' – 'a' beide den Wert 1. Aber: Die Differenz
'b' – 'A' ist 33!
3.6.1 Übung 4: Zeichen-Eingabe und „Rechnen mit Zeichen“



Geben Sie das Beispielprogramm aus diesem Abschnitt zunächst nur bis zu dem
Kommentar /*Eingabezeichen wieder ausgeben*/ ein. Wenn Sie diesen
Programmteil ausführen werden zwei Zeichen eingelesen und unverändert
ausgeben. Die Eingabezeichen müssen Sie bei dem Onlinecompiler in das "Textfeld
für die Dateneingabe des Programms (stdin)" schreiben, und zwar bevor Sie das
Webformular mit der Schaltfläche
abschicken.
Testen Sie das Programm mit beliebigen Zeichen, z.B. auch mit dem NewlineZeichen (Enter-Taste). Frage an Fortgeschrittene mit Computer-Vorwissen: Mit
welchen Zeichen funktioniert das Programm nicht richtig wenn man den OnlineCompiler benutzt? Welches Zeichen wäre ein konkretes Beispiel?
Vervollständigen Sie nun das Programm. Die Programmzeile ganze_zahl = ...
wandelt die Folge der beiden Eingabezeichen in eine zweistellige Dezimalzahl um.
Dabei erhält das erste Zeichen die Stellenwertigkeit 10 und das zweite Zeichen die
Wertigkeit 1. Nur wenn die beiden Eingabezeichen tatsächlich Dezimalziffern sind
(0 ... 1) erhält man das erwartete Ergebnis. Testen Sie auch mit anderen Zeichen
und versuchen Sie das jeweilige Ergebnis nachzuvollziehen.
11
3 Modul 1 - Kommandozeilen-Programm mit Aus- und Eingabe
3.7
Rechnen mit Programmvariablen
#include <stdio.h>
int main (void)
{
int a = 15;
int b, c;
b = 3; /* hier wird b ein Wert zugewiesen */
c = a + b; /* Summe von a und b an c zuweisen */
printf("a+b= %i", c);
return 0;
}
Das Beispielprogramm in diesem Abschnitt enthält drei Integer-Variable mit den Namen
a, b und c. Mit der Anweisung c = a + b; erhält die Variable c den Wert, der durch
die Addition der Werte von a und b berechnet wird. Die Werte der Variablen a und b
ändern sich dadurch nicht. Anders als in der Mathematik bedeutet c=a+b nicht, dass auf
beiden Seiten des Gleichheitszeichens gleiche Werte bzw. Größen stehen. Vielmehr ist das
Gleichheitszeichen (=) in der Programmiersprache C ein Operator (der
Zuweisungsoperator), der einer Speicherstelle einen neuen Wert zuweist. Der Variablen
(Speicherstelle) links von dem Gleichheitszeichen wird genau der Wert zugewiesen, der
auf der rechten Seite steht bzw. dort als Wert eines Ausdrucks, wie z.B. "a + b",
berechnet wird. Das Pluszeichen (+) ist das Operatorsymbol für die Addition.
3.7.1 Übung 5: Wertzuweisung an eine Variable und Integer-Arithmetik



Lassen Sie das Programmbeispiel aus diesem Abschnitt übersetzen und ausführen.
Die Programmausgabe muss das Ergebnis der Berechnung der Summe der beiden
Variablen a und b zeigen.
Ändern Sie Ihr Programm so, dass nicht nur der Wert der Variablen c, sondern
auch die Werte der Variablen a und b ausgegeben werden.
Programmieren Sie die Ausgabe des Produkts von a und b, statt der Summe. Das
Operatorsymbol für die Multiplikation ist das Sternzeichen (*).

Variieren Sie das Programm durch verschiedene Zahlenwerte für a und b sowie
verschiedene arithmetische Operatoren: + - * / %.

Der Operator für die Division / produziert für ganzzahlige Operanden (Integer)
ebenfalls ein ganzzahliges Ergebnis. Ein weiterer arithmetischer Operator
speziell für Integer-Zahlen ist der Modulo-Operator % ("Restwert-Operator").
Testen Sie den Modulo-Operator mit verschieden Werten für a und b.
12
3 Modul 1 - Kommandozeilen-Programm mit Aus- und Eingabe
3.8
Was Sie aus Modul 1 mitnehmen sollen
ASCII-Tabelle
Tabelle mit einheitlichen Grundzeichensatz
Dezimalzahl
Hexadezimalzahl
Stellenwertsystem zur Basis 10
Stellenwertsystem zur Basis 16
Programmrahmen
Standard-Eingabe
Standard-Ausgabe
Variablen
Anweisungen
Kommentar
Syntax und Syntaxfehler
Datentypen
char
int
string
stdin
stdout
Dienen als Platzhalter für beliebige Werte eines Datentyps
Werden vom Programm ausgeführt und enden mit einem
Semikolon ( ; )
/* … */ Werden vom Programm ignoriert, dient der
Beschreibung
Programm-„Grammatik“ bzw. Fehler dieser „Grammatik“
Beschreiben den Typ einer Variable
character steht für ein Zeichen
integer ist eine ganze Zahl
Auch Zeichenkette, beschreibt eine Zeichenfolge (Dient
nicht als Datentyp!)
Operator, Operatorsymbol
=
+ - * /
%
Zuweisungsoperator
Arithmetische Operatoren
Modulo-Operator
Ausgabefunktionen
putchar( )
printf( )
Gibt ein Zeichen (char) aus
Gibt eine formatierte Zeichenkette aus
Formatelemente
%c
%i
%s
\n
Platzhalter für einen char
Platzhalter für einen int
Platzhalter für einen string
Newline
Parameter, Parameterliste
Wert bzw. Werteliste für die Formatelemente
13
Document
Kategorie
Technik
Seitenansichten
16
Dateigröße
1 138 KB
Tags
1/--Seiten
melden