Einführung in die imperative Programmierung

Muss-Regeln

1. Selbstdefinierte Konstantenbezeichner bestehen nur aus Großbuchstaben. Bezeichner von Standardkonstanten wie z.B. maxint sind also ausgenommen.

2. Typenbezeichnern wird ein t vorangestellt. Bezeichnern von Zeigertypen wird ein tRef vorangestellt. Bezeichner formaler Parameter beginnen mit in, io oder out.

3. Jede Anweisung beginnt in einer neuen Zeile. begin und end stehen jeweils in einer eigenen Zeile.

4. Anweisungsfolgen werden zwischen begin und end um eine konstante Anzahl von 2-4 Stellen eingerückt. begin und end stehen linksbündig unter der zugehörigen Kontrollanweisung, sie werden nicht weiter eingerückt.

5. Anweisungsteile von Kontrollanweisungen werden genauso eingerückt.

6. Im Programmkopf wird die Aufgabe beschrieben, die das Programm löst.

7. Jeder Funktions- und Prozedurkopf enthält eine knappe Aufgabenbeschreibung als Kommentar. Ggf. werden zusätzlich die Parameter kommentiert.

8. Die Parameter werden sortiert nach der Übergabeart: Eingangs-, Änderungs- und Ausgabeparameter.

9. Die Übergabeart jedes Parameters wird durch Voranstellen von in, io oder out vor den Parameternamen gekennzeichnet.

10. Das Layout von Funktionen und Prozeduren entspricht dem von Programmen.

11. Jede von einer Funktion oder Prozedur benutzte bzw. manipulierte Variable wird als Parameter übergeben. Es werden keine globalen Variablen manipuliert.

12. Jeder nicht von der Prozedur veränderte Parameter wird als Wertparameter übergeben. Lediglich Felder können auch anstatt als Wertparameter als Referenzparameter übergeben werden, um den Speicherplatz für die Kopie und den Kopiervorgang zu sparen. Der Feldbezeichner beginnt aber stets mit dem Präfix in, wenn das Feld nicht verändert wird.

13. Pascal-Funktionen werden wie Funktionen im mathematischen Sinne benutzt, d.h. sie besitzen nur Wertparameter. Wie bei Prozeduren ist eine Ausnahme nur bei Feldern erlaubt, um zusätzlichen Speicherplatz und Kopieraufwand zu vermeiden.

14. Wertparameter werden nicht als lokale Variable missbraucht.

15. Die Laufvariable wird innerhalb einer for-Anweisung nicht manipuliert.

16. Die Grundsätze der strukturierten Programmierung sind strikt zu befolgen.

Beispiel für ein strukturiertes Programm:

program Binaerbaum (input, output);               {Regel 16}
{Verwaltet einen Binärbaum}                       {Regel 6}

  const
  NULL=0;                                         {Regel 1}                   
  EINS=1;
  F=false;
  T=true;
      
  type
  tRefBinBaum= ^tBinBaum;                         {Regel 2}
  tBinbaum= record                                {Regel 2}
              info: integer;
              links:tRefBinBaum;
              rechts:tRefBinBaum;
            end;

  var 
  wurzel : tRefBinBaum;
  Zahl: integer;
      
  procedure einf(inWert:integer; 
                 var ioBaum:tRefBinBaum);                      {Regel 2,8,9,11,12} 
  {fügt inWert als neuen Knoten in den Baum ein}               {Regel 7}
    var
    Zeiger: tRefBinBaum; 
  begin                                                        {Regel 10}
    if ioBaum=nil then
    {Baum ist noch leer}
    begin
      new(Zeiger);
      Zeiger^.info:=inWert;
      Zeiger^.links:=nil;
      Zeiger^.rechts:=nil;
      ioBaum:=Zeiger;                                          {Regel 14}
    end
    else
    begin
      if inWert <= ioBaum^.info then
      {Wert links einfügen}
      begin
        if ioBaum^.links=nil then
        {einfügen}
        begin
          new(Zeiger);
          Zeiger^.info:=inWert;
          Zeiger^.links:=nil;
          Zeiger^.rechts:=nil;
          ioBaum^.links:=Zeiger;
        end
        else
        {links weitersuchen}
          einf(inWert, ioBaum^.links);
      end;
      if inWert > ioBaum^.info then
      {Wert rechts einfügen}
      begin
        if ioBaum^.rechts=nil then
        {einfügen}
        begin
          new(Zeiger);
          Zeiger^.info:=inWert;
          Zeiger^.links:=nil;
          Zeiger^.rechts:=nil;
          ioBaum^.rechts:=Zeiger;
        end
        else
        {rechts weitersuchen}
          einf(inWert, ioBaum^.rechts);
      end;
    end;
  end;   

  function finden(inBaum:tRefBinBaum; 
                  inWert:integer): boolean;                            {Regel 9,11,13}
  {sucht inWert im Baum und gibt true oder false zurück}               {Regel 7}
  begin
    if inBaum=nil then
    {Knoten leer}
      finden:=F
    else
      if inBaum^.info=inWert then
      {Wert gefunden}
        finden:=T
      else
      {links und rechts suchen}
        finden:=finden(inBaum^.links,inWert) or finden(inBaum^.rechts,inWert);
  end;

BEGIN                                                                 {Regel 3}
  {Baum aufbauen}                                                     {Regel 4}
  wurzel:=nil;                                                        {Regel 3}
  einf(NULL, wurzel);
  einf(EINS , wurzel);
  einf(9, wurzel); 
  einf(5, wurzel);
  einf(3, wurzel);
  einf(10, wurzel);
  einf(EINS, wurzel);
  
  for Zahl:= 20 to 30 do
  begin
    einf(Zahl, wurzel);
    {Zahl := Zahl+1; ist auskommentiert}				               {Regel 15}
  end; 
   
  {im Baum suchen}
  Zahl:=0;
  while Zahl >= 0 do
  begin
    writeln('Nach Zahl suchen, Abbrechen mit negativer Zahl');        {Regel 5}
    readln(Zahl);
    if Zahl>=0 then
      writeln(finden(wurzel, Zahl)); 
  end;
END.