Aus der Welt eines Azubis– Standard Pascal; eine Übersicht;

Die Programmiersprache Pascal (übrigens nach dem Mathematiker Blaise Pascal benannt), ist eine 1972 von Niklaus Wirth eingeführte Lehrsprache, die auf Algol 60 basiert.
Nikolaus Wirt hat damals an der ETH (Eidgenössische Technische Hochschule) Zürich als Professor für Informatik unterrichtet  und wollte seinen Studenten mit Pascal eine so einfach und strukturiert wie möglich gehaltene Sprache bieten, mit der sie die strukturierte Programmierung leichter erlernen könnten.

Auch heute noch wird diese Sprache  Anfängern zum Einstieg in die strukturierte Programmierung näher gebracht, damit diese Grundlagen erlernen und ihren Programmcode besser zu strukturieren. Diese Erfahrung durfte auch ich im Rahmen meiner im Februar begonnen Ausbildung machen – übrigens ist das auch der Grund, weshalb ich mein erstes Postthema Pascal widmen möchte.

Im Folgenden werde ich versuchen die Syntax von Standard Pascal grob zu erläutern und anschließend an einem Beispiel zu vorzustellen.

Programmkopf

Hier findet man den Namen des Programms und eventuelle Schnittstellen des Programms nach außen.

Der Name kann beliebig gewählt werden, muss nur mit den PASCAL-Namensregeln konform sein und darf kein weiteres mal im Programm vorkommen.

Program Beispielprogramm (input, output, datei1, datei2);

Vereinbarungsteil

Alle Variablen, Typen und Funktionen (ob mit Rückgabewert –function– oder ohne–procedure–) werden hier deklariert. Theoretisch ist dieser Absatz nicht zwingend notwendig, praktisch ist er aber unerlässlich, um viele Problemstellungen effizient lösen zu können.

Typen gibt es in Standard Pascal einige, hier die gebräuchlichsten :

• Integer
  – belegt 16 Bit –> Zahl von  -32768 bis 32767
• Char
  – belegt im Fall von ASCII 7 Bit –> einzelnes Zeichen
• Boolean
  – belegt 8 Bit –> Wahr (true) oder Falsch(false)
• Record
  – variabler Speicherverbrauch –> ist quasi ein Container der andere Typen beinhalten kann

type
     Benennung1(, Benennung2,…) = Typ;

var
      Benennung1(, Benennung2,…) : Typ;

function BenennungFunktion (BenennungMöglicheEingangsvariable : Typ) : RückgabewertTyp;
                begin
                           Anweisung1;
                           Anweisung2;
                           BenennungFunktion := Ergebnis vom Typ RückgabewertTyp;
                end;

procedure BenennungFunktion (BenennungMöglicheEingangsvariable : Typ)
               begin
                          Anweisung1;
                          Anweisung2;
               end;

Anweisungsteil

begin
           Anweisung1;
           Anweisung2;
end.

So viel zum regulärem Aufbau, doch wie sieht es in so einem begin – end Abschnitt genau aus und welche Operationen kann man dort ausführen? Dazu erst einmal eine Operatorenübersicht

Arithmetische Operatoren

1. Addition(+)
2. Subtraktion(-)
3. Multiplikation(*)
4. Division(/) –> mit Zahlen nach dem Komma
5. Division(DIV) –> ganzzahlig
6. Modulo(MOD) –> gibt den Rest einer Division aus

Vergleichsoperatoren

1. Gleich(=)
2. Ungleich(<>)
3. Kleiner(<)
4. Kleiner oder Gleich (<=)
5. Größer(>)
6. Größer oder gleich(>=)

Logische Operatoren

1. Negation(NOT)
2. Konjunktion(AND)
3. Disjunktion(OR)

Weitere unerlässliche Werkzeuge sind Verzweigungen und Schleifen

Verzweigungen

Verzweigungen braucht man immer dann, wenn man Variablen differenziert behandeln möchte.

• if-then-else
  wobei else optional ist, der Pseudocode sieht in etwa so aus:

  wenn Bedingung zutrifft dann Anweisung wenn nicht Anweisung

  wenn man das Ganze in Pascal benutzen will, sieht die Syntax so aus:
  if Bedingung then begin Anweisung1; Anweisung2 end else begin Anweisung1; Anweisung2 end
  

• Case
  Mit Case kann man verschiedene Werte einer Variable behandeln, in Pseudocode :

  FälleDieserVariable Variable
       Fall VariableEnthältDas : Anweisung1;
       Fall VariableEnthältDasAndere : Anweisung2;

  Hier die Syntax mal am Beispiel eines Integer Wertes:
  Case intName Of
        10 : Anweisung1; (mehrere Anweisungen kann man auch hier mit einem begin-end Block integrieren)
        42 : Anweisung2;

  Wenn intName also 10 ist wird Anweisung1 ausgeführt, bei 42 Anweisung2.

Schleifen

• while-do
  Diese Schleife wird kopfseitig geprüft, d.h. sie wird nur durchlaufen wenn die Bedingung gegeben ist (Äquivalent siehe repeat-until)
  Pseudocode:
  solange Bedingung true Anweisung;

  Pascalcode am Beispiel einer Boolean Variable:
  while BooleanVariable = true do BooleanVariable := false; (oder begin-end Block)

  Nach reichlicher Überlegung erkennt das gehschulte Auge, dass diese Schleife genau einmal durchlaufen wird und dabei die Abbruchbedingung setzt.
  

• repeat-until
  Diese Schleife wird fußseitig geprüft, d.h. sie wird zumindest ein mal durchlaufen (Äquivalent siehe while-do)Pseudocode:
  true Anweisung; solange Bedingung;

  Pascalcode am Beispiel einer Boolean Variable:
  repeat BooleanVariable = true; (oder begin-end Block) until BooleanVariable := false;

  Nach reichlicher Überlegung erkennt das gehschulte Auge das diese Schleife genau ein mal durchlaufen wird und dabei die Abbruchbedingung setzt auch wenn diese bereits gesetzt ist.

Aufbau eines Beispielprogramms

(*Hier ein kleines Programm, das alle natürlichen Zahlen eines vom Benutzer vorgegebenen Startwertes bis zu einem ebenso vorgegebenen Endwert addiert und ausgibt. *)

(*-----------------------------------PROGRAMMKOPF-----------------------------------*)

program Example;

(*--------------------------------VEREINBARUNGSTEIL-------------------------------*)

var startValue, endValue, sum: integer;  

function PrintSum(startV : integer; endV : integer) : integer;      (*--> addiert natürlichen Zahlen vom Startwert bis Endwert*)
          begin
                     for startV := startV to endV do                (*--> Schleife bis endV erreicht ist*)
                     sum := sum+ startV;                            (*--> addiere jeden Wert mit sum*)

                     PrintSum := sum;                               (*--> setze den Rückgabewert*)
          end; 

(*---------------------------------ANWEISUNGSTEIL---------------------------------*)

begin    (*--> leite Anweisungsteil ein*)  
 
writeln('Bitte geben Sie den Startwert ein!');                      (*--> instruiere den Nutzer*)
readln(startValue);                                                 (*--> Startwert einlesen*)
 
writeln('Bitte geben Sie den Endwert ein!');                        (*--> instruiere den Nutzer*)   
readln(endValue);                                                   (*--> Endwert einlesen*)
   
writeln;writeln;                                                    (*--> fügt zwei Leerzeilen hinzu – Übersichtlichkeit*)
  
write('Summe natuerlicher Zahlen--> ');   
writeln(PrintSum(startValue,endValue));                             (*--> Methode Ausführen und Ergebnis ausgeben*)
   
readln;
                                                             (*--> lässt das Programm auf eine Eingabe warten damit der    Nutzer noch genügend Zeit hat das Ergebnis zu lesen*)
end.       (*--> signalisiere das Ende vom Anweisungsteil*)

So viel zu Standard Pascal.