Prozedur (Programmierung)

Eine Prozedur ist in der Programmierung von Computersystemen eine benannte Folge von Anweisungen (möglicherweise mit Parametern), die es erlaubt, bestimmte Aufgaben in wiederverwendbarer Art zu formulieren. Man unterscheidet eigentlich

• offene Prozedur (Makro)
• geschlossene Prozedur (Unterprogramm)

Der entscheidende funktionale Unterschied ist, dass vom Rumpf eines Unterprogramms aus die Umgebung seiner Deklaration sichtbar ist, vom Rumpf eines Makros aus hingegen die seines Aufrufs.

Definitionsversuche wie Ein Makro wird vor der eigentlichen Kompilierung in den Quelltext hineinkopiert. skizzieren lediglich eine mögliche Form der Implementierung oder ein in dieser Form etwas unscharfes Erklärungsmodell.

Beispiel für den Unterschied zwischen Unterprogramm und Makro in C (getestet mit Borland C++ Compiler):

#include <stdio.h>
#include <stdlib.h>
 
int main(void)
{   int i=1;
    void    aus_unter  (); {printf("%d\n", i);}
    #define aus_makro_i()   printf("%d\n", i)
    #define aus_makro_j()   printf("%d\n", j)

    {   int i=2, j=3;
        aus_unter    ; /* gibt die Zahl 1 aus */
        aus_makro_i(); /* gibt die Zahl 2 aus */
        aus_makro_j(); /* gibt die Zahl 3 aus */
    }
    return EXIT_SUCCESS;
} /* end main() */

Das Unterprogramm aus_unter wird stets die mit 1 initialisierte Variable i aus dem selben äußeren Block ausgeben, da nur diese von der Stelle der Unterprogramm-Deklaration aus sichtbar ist.

Das Makro aus_makro_i hingegen wird stets die Variable i ausgeben, die an der Stelle seines Aufrufs sichtbar ist. Dies ist im Beispiel die mit 2 initialisierte Variable i aus dem inneren Block.

Im Gegensatz zu einem entsprechenden Unterprogramm ist auch die Deklaration eines Makros aus_makro_j im äußeren Block zulässig, obwohl die darin angesprochene Variable j (noch) gar nicht sichtbar ist. Entscheidend ist lediglich, dass sie an der Stelle seines Aufrufs sichtbar ist. Dies ist im Beispiel die mit 3 initialisierte Variable j aus dem inneren Block.

Man spricht in diesem Zusammenhang von der Bindungsrelation zwischen deklarierenden (vereinbarenden) und angewandten Vorkommen der Bezeichner.

Sowohl in der Theorie als auch in manchen Programmiersprachen wird unter Prozedur bzw. procedure einschränkend wie auch im Folgenden speziell ein Unterprogramm verstanden:

Im Unterschied zur Funktion liefert eine Prozedur keinen Rückgabewert auf direktem Weg.

Im Allgemeinen kann eine Prozedur Aufrufparameter besitzen und auch die Werte von Variablen ändern. Man unterscheidet hier zwischen lokalen (nur innerhalb der Prozedur gültigen und von außen nicht beeinflussbaren) und globalen (außerhalb der Prozedur deklarierten) Variablen. Das Ändern globaler Variablen innerhalb einer Prozedur kann die Übersichtlichkeit des Programms beeinträchtigen und die Fehlersuche erschweren.

Prozeduren können wie Funktionen in Programmbibliotheken zusammengestellt werden. Hierdurch besteht die Möglichkeit, eine Prozedur auch aus anderen Programmen oder separaten Programmmodulen heraus aufzurufen. Durch die Möglichkeit, selbst Prozeduren und Bibliotheken erstellen zu können, kann der Programmierer den eigenen Code modular und wiederverwendbar gestalten.

Terminologie

Je nach Programmiersprache und Programmierparadigma gibt es Unterschiede in der Abgrenzung zwischen den Begriffen Funktion und Prozedur. FORTRAN77 beispielsweise fasst unter procedures Funktionen und prozedurale Unterprogramme (subroutines) zusammen. In der Terminologie des C-Standards ist jedwedes Unterprogramm eine Funktion, unabhängig davon, ob ein Wert zurückgeliefert wird. In der objektorientierten Programmierung werden beide Konzepte oft unter dem Sammelbegriff Methode zusammengefasst.

Prozedur als Unterprogramm

In der Programmierung tritt immer wieder der Fall auf, dass sich bestimmte Programmabschnitte wiederholen. Statt den Codeabschnitt jedes Mal zu kopieren, legt man ihn nur einmal an, versieht in mit einem Namen und ruft ihn an anderer Stelle über diesen Namen auf. Zur Laufzeit wird dann der betreffende Abschnitt durchlaufen. Einige Programmiersprachen (z. B. Pascal) unterscheiden bei der Deklaration explizit zwischen Funktion (mit Rückgabewert) und Prozedur (ohne Rückgabewert). In anderen Sprachen werden Prozeduren einfach als Funktionen oder Methoden ohne Rückgabewert realisiert. Im Gegensatz zur „reinen“ Funktion, deren einziger Effekt das nebenwirkungsfreie Liefern eines Wertes ist (z. B. Quadratwurzel einer Zahl), sind Prozeduren gerade wegen ihrer Nebeneffekte interessant, beispielsweise der Änderung von Speicherinhalten oder Ausgabeoperationen.

Entwicklung

In frühen imperativen Programmiersprachen (zum Beispiel frühe BASIC- und FORTRAN-Varianten) gab es nur das Konzept des parameterlosen Unterprogramms, welches über Sprunganweisungen aufgerufen wurde und ausschließlich über globale Variablen mit dem Hauptprogramm wechselwirken konnte.

Mit dem Aufkommen der strukturierten Programmierung entwickelte sich das Konzept der Prozedur mit Aufrufparametern, die zunächst überwiegend als Referenzparameter übergeben wurden (call-by-reference), das heißt eine Änderung des Parameters innerhalb der Prozedur ändert den zugehörigen Parameter an der Aufrufstelle der Prozedur. Die Einführung von expliziten Rückgabewerten von Prozeduren (respektive Funktionen) ermöglichte die Berechnung von Resultaten, ohne die Referenzparameter zu verändern.

In einem weiteren Schritt wurden Wertparameter zur Übergabe an Prozeduren eingeführt (call-by-value), um unerwünschte Rückwirkungen auf das Hauptprogramm weiter zu reduzieren.

Zur Vermeidung von Programmfehlern wurde in einigen Programmiersprachen wie zum Beispiel Pascal eine starke Typisierung von Parametern eingeführt: die tatsächlich verwendeten Parameter müssen hierbei relativ streng zuweisungskompatibel mit den formal deklarierten Parametern sein.

In Programmiersprachen wie Modula-2 können Prozedurvariablen aufgerufen oder als Parameter eingesetzt werden.

Schließlich wurden Prozeduren als objektbezogene Methoden oder Zugriffsfunktionen Bestandteil des objektorientierten Paradigmas, etwa in den Programmiersprachen Java und C++.

Beispiele

Die folgenden Beispiele definieren jeweils eine Prozedur zum Zeichnen einer Linie mit anzahl Punkten.

Pascal

In der Programmiersprache Pascal, die Prozeduren explizit als Sprachelement verwendet, gibt eine Prozedur im Gegensatz zu einer Funktion definitionsgemäß keinen Wert zurück:

Beispiel einer Prozedur in Pascal:

  PROCEDURE Punkte_zeichnen(Anzahl:Integer);
  VAR
    i:Integer;
  BEGIN
    FOR i := 1 TO Anzahl DO
    BEGIN
      Write('.');
    END;
  END;

Beispiel eines Prozeduraufrufs in Pascal:

  Punkte_zeichnen(5);

BASIC

Realisierung einer Prozedur in einer modernen BASIC-Variante (Subroutine ohne Rückgabewert):

  Public Sub Punkte_zeichnen(anzahl As Integer)
    For i As Integer = 1 To anzahl
      Debug.print (".")
    Next i
  End Sub

Beispiel eines Methodenaufrufes in Basic:

  Call Punkte_zeichnen(5)

C

Realisierung einer Prozedur in C. Das Schlüsselwort void legt fest, dass die Funktion keinen Rückgabewert liefert:

  void Punkte_zeichnen(int anzahl) {
    for (int i = 0; i < anzahl; i++) {
      putchar('.');
    }
  }

Beispiel eines Funktionsaufrufs in C:

  Punkte_zeichnen(5);

Java

Realisierung einer Prozedur in Java (Methode ohne Rückgabewert):

  public void Punkte_zeichnen (int anzahl) {
    for (int i = 0; i < anzahl; i++) {
      System.out.print (".");
    }
  }

Beispiel eines Methodenaufrufs in Java:

  Punkte_zeichnen(5);