Routinen: Prozeduren und Funktionen - 1

Die Verwendung von Unterprogrammen vermeidet eine Vervielfältigung des Codes, wenn derselbe Code an verschiedenen Programmstandorten nicht ohne weiteres verfügbar ist.
Die in das Programm importierten Bibliotheken (z.B. Mathemathematische Bibliothek) bestehen aus Teilprogrammen, die bereits von jedem erstellt wurden. Die Programmierer müssen nicht darüber nachdenken, welche Algorithmen sie tragen, aber sie benutzen sie einfach, um darüber nachzudenken, was sie tun. Es ist eine große Zeitersparnis. Es gibt keine Notwendigkeit, einen Algorithmus zu schreiben, der von jedem geschrieben wurde.

Jedes UnterprogrammEine Aufgabe sollte sein:entweder einfach etwas berechnen oder Daten machen oder etwas anderes tun.

Es gibt zwei Arten von Unterprogrammen: Verfahren und Funktion

Die Unterprozeduren führen bestimmte Aktivitäten durch, beispielsweise führen zu einer bestimmten Form von Ergebnissen (Beispiel: Operator) Schreibln()- ist ein gestaffeltes Unterprogramm-Verfahren, das Informationen aufzeigt)

Funktionen Rückblick (Zahl, Symbolzeile, etc.), die wir im Hauptprogramm verwenden können.

Versuchen wir, ein einfaches Verfahren zu schreiben:
Sagen wir, wir müssen die Error-Zeile jedes Mal auf den Bildschirm stellen, wenn der Code einen Fehler durch den Fehler des Benutzers macht (z.B. wenn er falsche Daten einführt)
Dies könnte durch Schreiben des Bedieners geschehen.

schriftlich('Error');

Lassen Sie uns jetzt vorgeben, dass diese Linie in viele Programmorte eingefügt werden muss. Natürlich können Sie es überall schreiben. Aber diese Entscheidung hat zwei Mängel.
(1) Diese Zeile wird oft gespeichert
(2) Wenn wir die Schlussfolgerung im Fehlerfall ändern wollen, müssen wir diese Linie im gesamten Programm ändern, was sehr unangenehm ist.

In diesen Fällen sind Verfahren erforderlich.
Das Programm mit dem Verfahren kann wie folgt aussehen:

#
mit Namespace std;

Prozedur printError(); // Verfahrensbeschreibung
Anfang
Schreibln('Error'); / Körper des Verfahrens - Teams, die das Verfahren durchführen
Ende;

/ Grundprogramm
beginnen;
#
printError(); // Beginn des Verfahrens zur Umsetzung. Zeigen Sie einfach den Namen des Verfahrens, das wir tun wollen.
#
printError();
#
Ende.

Das Verfahren beginnt mit dem Wort procedure♪ Nach dem Verfahren werden die Variablen und deren Typen angezeigt, auf denen das Verfahren durchgeführt werden soll. Zum Beispiel:

var a, b, Antwort: Ganzzahl;
Verfahren Sum(a, b: ganze Zahl);
Anfang
Antwort := a + b;
Ende;

Alle Betreiber, die das Verfahren durchführen, werden mit Ausnahme registriert.

Verfahren vor dem Hauptprogramm

Um das Verfahren durchzuführen, muss das Hauptprogramm es verlangen. nicht vergessen, Klammern zu schreiben!
Sie können die Prozedur im Programm jederzeit anrufen.

Nun, lassen Sie uns vorstellen, dass wir brauchen, in Reaktion auf den Benutzer ' s Fehler, verschiedene Nachrichten, was auch immer der Fehler, den er gemacht hat.
In diesem Fall ist es möglich, dass jeder Fehler seine Prozedur schreibt:

Prozedur printErrorZero();
Anfang
Schreib. Division um null!
Ende;

Prozedur printErrorInput();
Anfang
schriftlich('Error in input!');
Ende;

Und wenn es noch viel mehr Fehler gibt? Das ist keine Lösung.
Wir müssen lernen, wie man das Verfahren durchführt, indem wir ihr sagen, was für ein Irrtum Sie machen müssen.
Dazu brauchen wir die Parameter, die wir nach dem Verfahren in runden Klammern aufnehmen werden.

Prozedur printError(s): string;
Anfang
Schreibwaren,
Ende;

Bei diesem Verfahren ist s ein Parameter - eine spezielle Variable, die den Ablauf des Verfahrens ermöglicht.
Wenn nun das Verfahren aufgerufen wird, sollte in Klammern der tatsächliche Wert angegeben werden, der dem Parameter (ersetzt s) innerhalb unseres Verfahrens zugewiesen wird.

printError('Error! Division um null!

Das nennt man ein Argument. Argument kann nicht nur konstant, sondern auch variabel oder arithmetisch sein.

Es besteht oft die Notwendigkeit, zusätzliche Variablen nur im Unterprogramm zu verwenden. Diese Variablen werden aufgerufen Ort Sie können nur innerhalb des Teilprogramms arbeiten, in dem sie eingerichtet werden.

So kann nur das Teilprogramm, in dem es wirklich benötigt wird, den Umfang begrenzen (oblastig der Sichtbarkeit). Es heißt die Software. Inc. ♪ Schließung der Variablen durch externe Veränderung.

Ist eine Variable an jedem Programmort (in einem Teilprogramm) sichtbar zu erklären, so sind diese Variablen außerhalb aller Teilprogramme zu beschreiben (siehe Programm 3 der nachstehenden Tabelle).
Diese Variablen werden aufgerufen weltweit♪

Analyse der drei Programme:

(1) In diesem Programm ist die Variable i lokal. Lokale Variablen werden im Teilprogramm beschrieben	(2) Hier, auch wenn im Hauptprogramm eine Variable i vorhanden ist (Wert 7), eine neue lokale Variable i mit einem Wert von 5. Das Programm wird Auswirkungen auf den Bildschirm haben	(3) Dieses Programm existiert globale Variable i. Ihre Auswirkungen können innerhalb des Unterprogramms und innerhalb des inhaltlichen Programms geändert werden Das Verfahren wird mit der globalen Variablen i arbeiten und eine neue Bedeutung von 2 erhalten. Der Bildschirm ist mit 2 zu versehen.
Verfahrenstest(); var i: ganze Zahl; Anfang : = 5; Schreibln(i); Ende;	var i: ganze Zahl; Verfahrenstest(); var i: ganze Zahl; Anfang : = 5; Schreibln(i); Ende; Anfang : = 7; Schreib(i) Test(); Ende.	var i: ganze Zahl; Verfahrenstest(); Anfang : = 2. Ende; Anfang Test(); Schreibln(i); Ende.

Ziel: ein Verfahren entwickeln, das die Orte der beiden Variablen verändert.
Die Besonderheiten dieser Aufgabe sind, dass wir die Änderungen des Verfahrens, das dem herausfordernden Programm bekannt ist, vornehmen müssen.

Versuchen wir, so ein Verfahren zu schreiben:

var x, y: ganze Zahl;

Verfahren Swap (a, b: ganze Zahl); / mit einer solchen Beschreibung der Parameter des Verfahrens,
var c: ganze Zahl;
beginnen // kopieren Sie die Argumente (x und y)
/ Variablen a und b - unabhängige Variablen, die nicht mit x und y zusammenhängen
c: = a;
a: = b;
b: = c;
Ende;

Anfang
x := 1;
= 2.
Swap (x, y); / Werte der Variablen x und y (Argumente) werden auf die Parameter a und b kopiert
Schreibln('x = ', x, ', y = ', y; / x = 1, y = 2
Ende.

Wenn dieses Programm gestartet wird, ist zu erkennen, dass die Variablenwerte variabel sind. x und y Keine Veränderung. Für die Parameter zur Änderung der Bedeutung der Argumente ist es notwendig, Übertragung von Referenzdaten.Zu diesem Zweck sollte nach dem Namen der Art der Daten der Titel des Teilprogramms eingefügt werdenvar

Verfahren Swapvar a, b: ganze Zahl); // nun die Variablen a und b erhalten die Variablen x und y im Speicher
var c: ganze Zahl;
Anfang
c: = a;
a: = b;
b: = c;
Ende;

Anwendung: Wenn Sie das Argument auf der Referenz, dann wenn Sie das Verfahren anrufen, kann der einzige Name der Variable an dieser Stelle sein.Nicht Zahl und nicht arithmetisch Ausdruck!

Der NEXT ruft das Verfahren auf:

Swap (x, ANHANG;
Swap5+x, y);