P
ASCAL
- P
ROGRAMMENTWICKLUNG
E
INFÜHRUNG
Programmiersprachen
- Zeichen und Befehlsvorrat um dem Rechner (PC) verständlich eine bestimmte Arbeitsweise
vorzuschreiben
- der Zeichenvorrat muß dem Rechner bekannt oder durch entsprechende Programme bekannt
gemacht werden
Einteilung der Programmiersprachen
* maschinenorientierte ( Assembler)
* problemorientierte Sprachen
- problemorientierte Sprachen verfügen gegenüber maschinenorientierte Sprachen über keine so
große Abweichung von der menschlichen Sprache
- zur Übersetzung benötigen problemorientierte Sprachen sogenannte Compiler oder Interpreter
- Interpreter = Programm, das ein in einer Hochsprache geschriebenes Programm während
der Programmausführung in den Maschinencode überträgt
- Compiler = Programm, das ein in einer Hochsprache geschriebenes Programm vor der
Programmausführung in den Maschinencode überträgt (dadurch schnellerer
Programmablauf);
Pascal
- weitverbreitete Programmiersprache für nahezu alle möglichen Anwendungen (Text, Dateiarbeit,
Datenbanken, Grafik, Spiele usw.)
- arbeitet mit einem Compiler und IDE (integrierten Entwicklungsumgebung, Benutzeroberfläche
WORKS- ähnlich)
P
ROGRAMMIERUNG
Programm
- durch Computerbefehle und Anweisungen konkretisierte Algorithmen zur Erledigung spezifischer
Aufgaben durch den Rechner
Algorithmus
- eindeutig bestimmtes Verfahren zur schematischen Lösung einer Klasse von Aufgaben (allg.:
Vorgehens- oder Arbeitsweise)
- beschreibt: was, in welcher Reihenfolge und in welcher Abhängigkeit getan werden muß, um zu
einem Ergebnis zu kommen;
die sieben Elemente der Programmierung -
grafische Darstellung von Algorithmen
Sequenz (Folge)
Bsp.: Addition von 2 Zahlen
Struktogramm
> Zahl1
READLN(zahl1);
> Zahl2
READLN(zahl2);
Berechnung Summe (Zahl1+Zahl2)
summe:=zahl1+zahl2;
Summe > WRITE('Summe=',Summe);
Selektion (Auswahl)
a) zweiseitige
Wollen Sie (A)dd. oder (S)ubtr.? > WRITE('Wollen Sie (A)dd. od. (S)ub.?');
> Antwort
READLN(antwort);
> Zahl1 und Zahl2
READLN(zahl1,zahl2);
Antwort ='A'
IF Antwort= 'A' THEN ergebnis:=zahl1+zahl2
ja
nein
ELSE ergebnis:=zahl1-zahl2;
Berechng.Ergebnis
(Zahl1+Zahl2)
Berechng.Ergebnis
(Zahl1-Zahl2)
Ergebnis > WRITE('Ergebnis =',ergebnis);
b) einseitige
Wollen Sie (A)dd. oder (E)nde ? > WRITE('Wollen Sie (A)dd. od. (E)nde ?');
> Antwort
READLN(antwort);
Antwort ='A'
IF antwort ='A' THEN
ja
nein
BEGIN
> Zahl1 und Zahl2
READLN(zahl1,zahl2);
Berechng. Ergebnis
(Zahl1+Zahl2)
%
ergebnis:=zahl1+zahl2
WRITE('Ergebnis =', ergebnis);
Ergebnis >
END;
Programmende ! > WRITE(' Programmende !');
c) mehrseitige
Wollen Sie (A)dd.,(S)ub.,(M)ult. oder (D)iv. ? > WRITE('Wollen Sie (A)dd. od.
(S)ub.?');
> Antwort
READLN(antwort);
> Zahl1 und Zahl2
READLN(zahl1,zahl2);
falls Antwort = .
CASE antwort OF
'A'
'A':WRITE(zahl1+zahl2);
'M'
'M':WRITE(zahl1*zahl2);
'D'
'D':WRITE(zahl1/zahl2);
'S'
'S':WRITE(zahl1-zahl2);
Berechng.
Ergebnis
(Zahl1+Zahl2)
Berechng.
Ergebnis
(Zahl1*Zahl2)
Berechng.
Ergebnis
(Zahl1:Zahl2)
Berechng.
Ergebnis
(Zahl1-Zahl2)
END;
Ergebnis > Ergebnis > Ergebnis > Ergebnis >
Programmende ! > WRITE('Programmende !');
oder so
Wollen Sie (A)dd.,(S)ub.,(M)ult. oder (D)iv. ? > WRITE('Wollen Sie (A)dd. od.
(S)ub.?');
> Antwort
READLN(antwort);
> Zahl1 und Zahl2
READLN(zahl1,zahl2);
falls Antwort= .
CASE antwort OF
'A'
'A':ergebnis:=zahl1+zahl2;
'M'
'M':ergebnis:=zahl1*zahl2;
'D'
sonst
'D':ergebnis:=zahl1/zahl2;
ELSE ergebnis:=zahl1-zahl2;
Berechng.
Ergebnis
(Zahl1+Zahl
2)
Berechng.
Ergebnis
(Zahl1*Zahl
2)
Berechng.
Ergebnis
(Zahl1:Zahl2
)
Berechng.
Ergebnis
(Zahl1-
Zahl2)
END;
Ergebnis > WRITE('Ergebnis=',ergebnis);
Programmende ! > WRITE('Programmende !');
Zusatz: Arbeit mit Unterprogrammen, Nutzung der bei Folgen erstellten Programmen, Übung zum
Kopieren zwischen Fenstern (markieren, EDIT, COPY[Ctrl+Ins]{ins Clipboard kopiert},
Zielort aufsuchen, Einfügen [Shift+Ins])
Wollen Sie (A)dd.,(S)ub.,(M)ult. oder (D)iv. ? > WRITE('Wollen Sie (A)dd. od.
(S)ub...?');
> Antwort
READLN(antwort);
> Zahl1 und Zahl2
READLN(zahl1,zahl2);
falls Antwort = .
CASE antwort OF
'A'
'A': Addition;
'M'
'M': Multiplikation;
'D'
'D': Division;
'S'
'S': Subtraktion;
Addition
Multiplikation Division
Subtraktion
END;
Programmende ! > WRITE('Programmende !');
Wiederholungen
a) Zählschleife (kopfgesteuert)
> Anfangswert
READLN(anfangswert);
> Endwert
READLN(endwert);
Wdh. (für Wert=) von Anfangswert bis
Endwert
FOR wert:=anfangswert TO endwert DO
BEGIN
Ergebnis berechnen (Wert*Wert)
ergebnis:=wert*wert;
Ergebnis >
WRITELN(wert,'
Ergebnis=',ergebnis);
END;
Programmende ! >
WRITE('Programmende !');
b) Wiederholschleife(fußgesteuert)
> Zahl1
REPEAT
READLN(zahl1);
> Zahl2
READLN(zahl2);
Berechng. Summe (Zahl1+Zahl2)
summe:=zahl1+zahl2;
Summe > WRITE('Summe=',summe);
Wollen Sie noch einmal ? (J/N) > WRITE('Wollen Sie noch einmal ?
(J/N)');
> Antwort
READLN(antwort);
Wdh. bis Antwort = 'N'
UNTIL antwort='N';
Programmende ! > WRITE('Programmende !');
c) Solangeschleife (kopfgesteuert)
> Zahl1 {Anfangswert}
READLN(zahl1);
> Zahl2 {Endwert}
READLN(zahl2)
> ZahlS {Schrittweite}
READLN(zahlS);
solange Zahl1 <= Zahl2
WHILE zahl1<=zahl2 DO
BEGIN
tue Berechng. Y-Wert=4*zahl12-2*zahl1+3
>
ywert:=4*zahl1*zahl1-2*zahl1+3;
Zahl1 > WRITE('X=',zahl1);
Y-Wert > WRITELN('Y=',ywert);
Berechng. nächster Wert für Zahl1
(Zahl1 um ZahlS erhöhen)
zahl1:=zahl1+zahls;
END;
Programmende ! > WRITE('Programmende !');
Z
USAMMENFASSUNG
Ein Programm löst gestellte Aufgaben durch Manipulation von Daten. Es muß also:
E *Daten von irgendwoher erhalten (Eingabe)
*Platz für die Speicherung dieser Daten zur Verfügung halten(Deklaration)
V *Anweisungen zum Bearbeiten dieser Daten erhalten (Operationen, z.B. Berechnungen)
*3 Arten der Organisation zur Bearbeitung von Daten
-abhängigmachen von einer oder mehrerer Bedingungen (Selektion)
-einzelne Anweisungen oder Anweisungsfolgen lassen sich mehrfach wiederholen
-Anweisungsfolgen können als separate Einheiten formuliert werden, die von
verschiedenen Teilen des Programms aus nutzbar sind (Unterprogramme)
A *die Ergebnisse dieser Bearbeitung an den Benutzer ausgeben (Ausgabe)
-----> EVA-Prinzip
Aufbau eines PASCAL- Programms
Vereinbarungs- und Deklarationsteil
Kopfzeile
Globale Compilerdirektiven
Eigenständige Module bzw. Units
Globale Label-, Typ-, Konstanten-
und Variabelenvereinbarungen
Prozeduren und Funktionen
Kopfzeile
Lokale Label-, Typ-, Konstanten-
und Variabelenvereinbarungen
Programmanweisungen
Hauptprogramm
Programmanweisungen
PROGRAM bezeichner1;
{+I}
USES crt (wincrt)
VAR bezeichner2 :Real;
CONST bezeichner3=4;
PROCEDURE bezeichner4;
VAR bezeichner5, :Integer;
bezeichner, bezeichner7 :Real;
BEGIN ... END;
BEGIN
...;
...;
END.
Oberbegriffe der Programmierung
Eingabe, Datentypen, Operationen, Ausgabe, bedingte Ausführung, Schleifen, Unterprogramme
·
Eingabe - das Lesen von Daten aus einer Diskettendatei, von der Tastatur oder über eine andere
Schnittstelle
·
Datentypen - Konstanten, Variablen und Strukturen(Records), die numerische Werte (Integer-
und Realzahlen), Text (einzelne Zeichen und Zeichenketten) oder Adressen (von
Variablen, Strukturen und Routinen) enthalten
·
Operationen - Zuweisung von Werten an Variablen, Verknüpfung von Werten (Addition,
Division, ...), sowie Vergleiche (gleich, ungleich, größer, ...)
·
Ausgabe - das Schreiben von Daten auf den Bildschirm, in eine Diskettendatei, zu einem Drucker
oder einem anderen Ausgabegerät
·
Bedingte Ausführung - die Ausführung von Anweisungen nach einer Operation, wie einem
Vergleich
·
Schleifen - wiederholen die Ausführung von Anweisungen, wobei die Anzahl der
Wiederholungen entweder fest vorgegeben ist oder von einer Bedingung abhängt
·
Unterprogramme - sind Gruppen von Anweisungen, die von mehreren Stellen des
Programms aufgerufen werden können. Normalerweise findet dabei
eine Datenübergabe statt
Eingabe
Die Prozedur READLN :
- verlangt eine Eingabe mit Zeilenvorschub
- READ arbeitet auch so, unterläßt jedoch den Zeilenvorschub z.B.: Readln (Element0, Element1, ...)
Ausgabe
Die Prozedur WRITELN erzeugt eine Ausgabe mit Zeilenvorschub
- WRITE arbeitet auch so, unterläßt jedoch den Zeilenvorschub
Syntax
·
Writeln (Element0, Element1, ...) oder
·
Writeln (Element0:Feldbreite0, Element1:Feldbreite1, ...)
·
bei Fließkommazahlen noch Angabe d. Kommastellen
Writeln (Element0:Feldbreite0:Kommastellen0, Element1:Feldbreite1:Kommastellen1, ...)
Beispiele
Writeln (1, ' ',2); ---------->1_2
A:=1; B:=5; C:=100;Writeln (A, B, C); ---------->15100
Writeln (A:2, B:2, C:2); ---------->_1_5100
Writeln (2:b, B:B, C:B); ---------->____2____5__100
Datentypen
Integer, Fließkommazahlen, Text, Wahrheitswerte, Zeiger
·
Integer: ganze Zahlen wie -1, 5, 3000 oder 0
·
Fließkommazahlen: Werte, die Bruchteile ganzer Zahlen enthalten
(z. B. 234.349456761 -->2.334e+2)
·
Text: 'a', 'B', 'Emil', '>', '§'
·
Wahrheitswerte (
Booleans
): können nur zwei Werte annehmen, True - wahr, False - falsch
Integertypen (Ganzzahlen):
Typ Bereich Format
ShortInt
-128...127 1 Byte mit Vorzeichen
Integer
-32768...32767 2 Bytes mit Vorzeichen
LongInt
-2147483648.2147483647 4 Bytes mit Vorzeichen
Byte
0...255 1 Byte, vorzeichenlos
Word
0...65535 2 Bytes, vorzeichenlos
- für Integertypen ist die hexadezimale Notation möglich, z.B. 255 entspricht $FF
Realtypen:
Real
2,9*10-39 bis 1,7*1038 11-12 Stellen 6 Byte
Single
1,5*10-45 bis 3,4*1038 7- 8 Stellen 4 Byte
Double
5,0*10-324 bis 1,7*10308 15-16 Stellen 8 Byte
Extended
1,0*10-4951 bis 1,1*104932 19-20 Stellen 10 Byte
Comp
-9,2*1018 bis 9,2*1018 18-19 Stellen 8 Byte
Die Datentypen Single, Double, Extended und Comp sind nur mit numerischen Coprozessor verfügbar
(Schalter setzen).
Text: Typ string
String
(Zeichenketten) ist eine Folge von Zeichen, die den Datentyp char haben, ihm ist aber ein
Speicherbereich mit konstanter Größe zugeordnet. (maximal 255 Zeichen)
PROGRAM Nummer_2;
VAR
Name: STRING[30];{Einschränkung auf 30 Zeichen}
BEGIN
WRITELN('Wie heißen Sie?');
READLN(Name);
WRITELN('Hallo!, ',Name);
END.
Wichtige Befehle in Turbopascal
Ein- und Ausgabe
Zur Ausgabe von Zeichen bzw. Zeichenketten
Die Prozeduren zur Ausgabe sind WRITE und WRITELN. Dabei ist folgende Syntax zu beachten:
WRITE (name); Ausgabe der Variable name
WRITE (name1, name2) Ausgabe der Variable name 1 und name 2
WRITE ('Vorname:',name); Ausgabe der Zeichenkette Vorname: und der Variable name
Durch Ersetzen von WRITE durch WRITELN wird in jedem Fall die Ausgabe in einer neuen Zeile
erfolgen , während bei WRITE die Ausgaben ohne Zeilenvorschub aufeinander folgen.
Zur Ausgabe von Zahlen
WRITE (Zahl); die Variable Zahl wird mit ihrer tatsächlichen Stellenzahl linksbündig ausgegeben
WRITE (Zahl:n); die Variable Zahl wird rechtsbündig in einem Feld der Breite n ausgegeben
(beachte die zu erwartende Stellenzahl)
WRITE (Zahl:n:m); die Variable Zahl wird rechtsbündig in einem Feld der Breite n ausgeben mit m
Nachkommastellen
Die Eingabe von Werten erfolgt durch die Prozeduren READ und READLN
READLN (Wert); die Variable Wert wird in einer neuen Zeile eingelesen
READ (Wert1,Wert2); die Variablen Wert1 und Wert2 werden in dieser Reihenfolge nacheinander
eingelesen
Zur Eingabebestätigung ist in beiden Fällen die ENTER-Taste als Abschluss notwendig, der eingelesene
Datentyp ist durch den Vereinbarungsteil des Pascalprogramms festgelegt.
Alternative zum READ bzw. READLN ist der Befehl READKEY. Er benötigt keine
Eingabebestätigung durch die ENTER-Taste.
Taste: = READKEY; die Variable Taste wird eingelesen, sie erhält den Wert der momentan gedrückten
Taste, der Datentyp der Variablen ist CHAR
! beachte Möglichkeit durch Befehl UPCASE Kleinbuchstaben in Großbuchstaben umzuwandeln.(Nur
einzelne Zeichen)
z.B. Taste: =UPCASE(READKEY);
Logische Verknüpfungen
Sie werden zum Verknüpfen von mehreren Bedingungen genutzt. (Bedingungen in IF THEN, WHILE
DO, REPEAT UNTIL)
X1
X2
X1 AND
X2
X1 OR X2
NOT
(X1)
Wahr
Falsch
Falsch
Wahr
Falsch
Falsch
Falsch
Falsch
Falsch
Wahr
Wahr
Wahr
Wahr
Wahr
Falsch
Falsch
Wahr
Falsch
Wahr
Wahr
Erlaubte Rechenoperationen und Vergleichsoperatoren
Addition +
Subtraktion -
Multiplikation *
Division /
größer als >
kleiner als <
größer gleich >=
kleiner gleich <=
gleich =
ungleich <>
Syntax Funktion
INC(x)
x um 1 erhöhen
DEC(x)
x um 1 verringern
Length(S)
ergibt die Länge des
Strings S
STR(Z,S)
wandelt numerischen
Wert
Z in String S
VAL(S,Z,C)
Umkehr von STR,
Code C
X erg Funktion
erg:=Abs (x); real Absolutbetrag
erg:=Sin (x); real Sinus (Bogenmaß)
erg:=Cos (x); real Cosinus (Bogenmaß)
erg:=ArcTan (x); real Arcustangens
(Bogenmaß)
erg:=Exp (x); real Expotentialfunktion
reg:=Frac (x); real nicht ganzzahliger Anteil
erg:=Int. (x); real ganzzahliger Anteil
erg:=Ln (x); real nat. Logarithmus
reg:=Sqr (x); real Quadrat
reg:=Sqrt (x); real Quadratwurzel
erg:= Round (x); bel. Zahl gerundeter, ganzzahliger
Anteil
erg:=Trunc (x); bel. Zahl ganzzahliger Anteil (abgeschnitten)
erg:=x1 DIV x2; bel. Zahl Ergebnis ganzzahliger
Anteil des Quotienten
0 Kommentare