WikiDer > Algol 60

Algol 60

Algol 60 ist ein Programmiersprache was durch seinen Einfluss auf spätere Programmiersprachen immer noch wichtig ist. Nach einer ersten Version raus 1958 die endgültige Version erschien in 1960. Der Name algol ist eine Abkürzung für Algorithmische Sprache.

Geschichte

Algol entstand aus dem Wunsch heraus, eine maschinenunabhängige Programmiersprache zu schaffen, die der herkömmlichen mathematischen Notation möglichst nahe kommt. Wie die damals schon existierende Programmiersprache war Algol fortran für wissenschaftliche Zwecke bestimmt. Im Gegensatz zu den gleichzeitig aktiven Programmiersprachenentwicklern COBOL Die Designer von Algol hatten keine besonderen Möglichkeiten, Dateien zu bearbeiten oder mit nicht-numerischen Daten oder großen Geldbeträgen zu arbeiten.

Die erste Version, Algol 58, wurde 1958 entworfen. Diese Programmiersprache war eher eine Sammlung guter Ideen, aber nie als fertiges Produkt gedacht. Algol 60 kam 1960 als Ergebnis der Arbeit von John Backus, Peter Nauru und Edsger Dijkstraße. Der Amerikanische Berufsverband ACM beschlossen, dass diese Sprache die Standardsprache für die Anzeige wird Algorithmen in ihrem blatt Mitteilungen des ACM. Trotzdem ist Algol 60 in Nordamerika noch nie so populär geworden wie in Europa, möglicherweise weil die Menschen dort bereits an Fortran gewöhnt waren.

Algol 60 ist in der angegeben Überarbeiteter Bericht zur algorithmischen Sprache Algol 60 mit einem definierten Grammatik (BNF Damit konnte formal festgestellt werden, ob ein Programm syntaktisch korrekt war. Das Implementierung der Sprache war von späterer Bedeutung. In kurzer Zeit jedoch eine große Anzahl von Compiler für die primitiven Maschinen der Zeit, wie die X1, geschrieben. Natürlich mussten Einschränkungen festgelegt werden, zum Beispiel hinsichtlich der Länge von Namen oder der Größe und Genauigkeit von Zahlen, die Überarbeiteter Bericht sind nicht definiert. Ein Compiler für den PC ist noch verfügbar, weist jedoch einige Erweiterungen und Einschränkungen gegenüber der Originalversion auf, die verhindern, dass alle spezifischen Funktionen von Algol 60 angezeigt werden.

Eigenschaften von Algol 60

Diese Beschreibung richtet sich an Personen, die eine neuere Programmiersprache wie Pascal, C, Java oder Visual Basic kennen. Es ist keine vollständige Beschreibung oder Einführung in Algol 60.

Form des Programms

Ein Algol 60-Programm ist eine Reihe von Symbolen. Viele dieser Symbole sind Zeichen, die auf den meisten Tastaturen zu finden sind. Das Schlüsselwörter werden im Algol 60-Bericht fett gedruckt, wie z loslegen und wenn. Diese Wörter zählen als einzelnes Symbol und müssen beim Übersetzen als solches erkannt werden. Andere knifflige Zeichen sind 10, die in a . verwendet wird Gleitkommazahl, und die Charaktere ‘ und ’ zeigt den Anfang und das Ende einer Zeichenfolge an.

Wenn Algol 60 auf einem Computer implementiert ist, gibt es mehrere Möglichkeiten, diese Symbole anzuzeigen. Zum Beispiel gibt es eine Implementierung, bei der alle Schlüsselwörter in Anführungszeichen stehen: 'BEGIN' 'IF'. Dadurch unterscheiden sie sich von den BEGIN- und IF-Kennungen. Allerdings erschwert es das Tippen.

Sowie in fortran Leerzeichen haben keine Bedeutung.

Es gibt eine Implementierung von Algol 60, die den Doppelpunkt und das Semikolon nicht kennt und stattdessen .. und ., benutzt. Tatsächlich kann dies getan werden, ohne einen syntaktischen Konflikt zu erzeugen.

Aufbau des Programms

Ein Novum in Algol 60 ist die Blockstruktur und seitdem jede Sprache mit Blockstruktur, wie z C und Pascal als Sprache mit Algol-Struktur bezeichnet. Durch die Blockstruktur können mehrere Anweisungen gruppiert werden, indem sie zwischen den Symbolen platziert werden loslegen und Ende stellen. Eine solche Gruppe ist selbst eine Anweisung und wird als zusammengesetzte Anweisung oder (wenn sie Deklarationen enthält) als Block bezeichnet.

Dynamische Array-Deklaration

Die Größe von a Array kann dynamisch bestimmt werden. Da sich eine Array-Deklaration immer am Anfang eines Blocks befindet, muss die Größe des Arrays bekannt sein, wenn die Ausführung des Blocks beginnt. Beispielsweise:

loslegenganze Zahl n; n := .....; loslegenInteger-Array  Liste[1:n]; ganze Zahl ich; zum ich:=1 Schritt 1 bis um nein tun        Liste[i]=i; ..... EndeEnde

Datentypen

In Algol 60, alle Variablen deklariert werden. Dies zwingt den Programmierer, im Voraus darüber nachzudenken, welche Variablen benötigt werden und welchen Typ diese Variablen haben. Algol 60 hat drei Datentypen:

  • ganze Zahl: ganze Zahlen
  • Real: Zahlen mit fester relativer Genauigkeit
  • boolesch: logische Werte, die Werte wahr oder falsch nehmen

Die Standardform von Algol 60 hat keine variablen Strings, Zeichen, Datensätze und vom Programmierer definierten Datentypen. Es ist jedoch möglich, Zeichenfolgen in die Ausgabe aufzunehmen. Spätere Implementierungen von Algol kennen den Typ verkohlen.

Arrays Daten eines Typs enthalten. Die Anzahl der Dimensionen ist grundsätzlich unbegrenzt. Unter- und Obergrenze werden getrennt angegeben. Dies sind positive oder negative ganze Zahlen, deren Wert zum Zeitpunkt der Deklaration bekannt sein muss.

Blockstruktur

Variablen, die zu Beginn des Programms deklariert werden, werden als global bezeichnet: Sie können überall im Programm verwendet werden. Nach jedem loslegen Variablen können wieder deklariert werden. Wir nennen das lokal. Sie können nur im Block selbst einschließlich seiner inneren Blöcke verwendet werden, es sei denn, in einem inneren Block wird ein gleichnamiger Bezeichner erneut deklariert. Ein globales Array hat immer feste Grenzen. Ein lokales Array kann variable Grenzen haben. Neben gewöhnlichen lokalen Variablen, besitzenVariablen werden deklariert. Diese erhalten beim erneuten Aufruf des Bausteins ihren alten Wert. Das besitzenVariable ist schwierig zu verwenden, da sie nicht automatisch einen Anfangswert erhält und a besitzenArray mit variablen Grenzen ist schwer zu implementieren.

Übungen

Algol 60 hat eine begrenzte Anzahl von Aussagen:

Die Syntax lautet (in einer nicht ganz korrekten Version von BNF):

〈Zuweisung〉 ::= 〈Variable〉:=〈Ausdruck〉〈wenn-Anweisung〉 ::= wenn  dann  {sonst 〈Anweisung〉}〈für-Anweisung〉 ::= zum 〈Variable〉:=〈Anfangswert〉 Schritt   bis um  〈Endwert〉 {während } tun  〈Anweisung〉〈goto-Anweisung〉 ::= gehe zu 〈label〉〈prozeduraufruf〉 ::= 〈prozedurname〉 | 〈Verfahrensname〉 (〈Parameterliste〉)

Bemerkenswert ist das wenn-dann-sonst tritt nicht nur als Anweisung, sondern auch als Teil eines Ausdrucks auf. Als Beispiel geben wir zwei Möglichkeiten an, um die größere von zwei Zahlen zu berechnen. Im ersten Fall ist a wennAnweisung verwendet, in der zweiten die Zuweisung mit wenn-dann-sonst.

wenn a>b dann max:=a sonst max:=bmax:= wenn a>b dann ein sonst b

Im zweiten Fall ist die sonstKlausel zwingend.

Beispiel

Das folgende Programm verwendet beide Formen, um eine Reihe von Zahlen, die auf 0 enden, einzulesen und auf dem Bildschirm anzuzeigen. Da der Wert des zumVariable beim Verlassen der Schleife laut Definition undefiniert ist, wird die Anzahl der eingelesenen Zahlen separat gehalten.

Kommentar starten Verwendung von for-Anweisung; ganze Zahl maxn; text(1,'Maximale Anzahl von Zahlen='); maxn:=lesen(1); Start-Integer n, ich; Integer-Array a[1:maxn]; n:=0; zum i:=1,i 1 während a[i-1]>0 tunKommentar Die Anzahl der gelesenen Zahlen wird in n gehalten; loslegen       text(1,'Zahl '); schreiben(1,i); text(1,'='); a[i]:=lesen(1); wenn a[i]>0 dann n:=i Ende;    zum ich:=1 Schritt 1 bis um nein tunloslegen      schreiben(1,i); Text 1,' '); schreiben(1,a[i]); überspringen(1) EndeEndeEnde

Es gehe zu-Anweisung war der am häufigsten verwendete Befehl zur Steuerung des Programmablaufs zu der Zeit, als Algol 60 entwickelt wurde. Neben dem regulären Etikett hat Algol 60 auch den Schalter, ein Array, das vorab mit Etiketten gefüllt ist. Heutzutage ist die Verwendung von gehe zu in jeder Algolischen Sprache veraltet.

Verfahren und Funktionen

Die Deklaration und Verwendung von Prozeduren und Funktionen in Algol 60 ist denen in neueren Sprachen sehr ähnlich, hat aber eine etwas andere Form. Der Typ und die Methode zum Aufrufen der Parameter werden nicht in definiert, sondern hinter der Parameterliste und den Funktionen werden der Name des Typs gefolgt vom Basissymbol angezeigt Verfahren. Algol 60 führte die rekursiv Prozedur, die Prozedur, die sich selbst aufruft. Ein häufig verwendetes Beispiel ist die Lösung des Problems der Türme von Hanoi. Das Verfahren zum Nummer Stöcke von per Stock durch kleben zu lautet in Algol 60:

Verfahren Hanoi (von, nach, über, Nummer);Wert von,nach,über,Nummer;ganze Zahl von,bis,durch,Nummer;loslegenwenn Zahl>1 dann      Hanoi (von, über, nach, Nummer-1); text(1,'von'); schreiben (1, von); text(1,' bis '); schreiben (1, an); überspringen(1); wenn Zahl>1 dann     Hanoi (über,nach,von,Nummer-1)Ende

Dieses Programm wurde oft verwendet, um die Überlegenheit von Algol 60 gegenüber Programmiersprachen ohne Rekursion wie Fortran und Cobol zu demonstrieren.

Ein weiteres Beispiel für einen rekursiven Aufruf ist die folgende Funktion zum Extrahieren der n-ten Zahl aus der Fibonaccia-Folge zu entscheiden:

Ganzzahlverfahren fibonacci(n);Wert n;ganze Zahl n;loslegenwenn n<=2 dann   Fibonacci:=1 sonst  fibonacci:=fibonacci(n-1) fibonacci(n-2)Ende

In einigen Punkten unterscheidet sich die Vorgehensweise in Algol 60 tatsächlich von der Vorgehensweise in späteren Programmiersprachen. Neben numerischen und logischen Variablen können auch Prozeduren als Parameter dienen und für die Formalparameter zusätzlich zu den Call-by-Value nicht der Call-by-Referenz aber die Call-by-Name verwendet von denen Jensen-Gerät Kann Angewandt werden.

Die kuriose Art und Weise, wie der Rückgabewert der Funktion durch eine Zuweisung an den Namen der Prozedur angegeben wird, stammt aus fortran.

Ein komplettes Programm

Als Beispiel hier ein Programm, das den Mittelwert und die Standardabweichung einer vordefinierten Anzahl von einzugebenden Zahlen berechnet. 1965 war dies ein nützliches Programm für Studenten, da es keine Tabellenkalkulationen existierte, die es ihnen ermöglichte, die Berechnung mit einer Formel wie STABW.(A1:A10) durchzuführen. Natürlich ist die Zahl eine ganze Zahl und die einzugebenden Zahlen, der Mittelwert und die Standardabweichung sind reelle Zahlen. Wir geben weiter an, dass die Standardabweichung mit der Formel berechnet wird . Es sollte nicht vereinfacht werden zu denn das ergibt ein zu ungenaues Ergebnis, wenn die Abweichungen vom Mittelwert relativ gering sind. Das bedeutet, dass die eingelesenen Variablen in einem Array abgelegt werden müssen. In Algol 60 kann ein Array deklariert werden, das genau die Anzahl der zu lesenden Zahlen aufnimmt. Bei dem begrenzten Speicher der Computer von 1960 war dies eine sehr nützliche Funktion.

Das Programm sieht so aus, mit den Erklärungen in den Kommentaren so weit wie möglich:

Kommentar starten Berechnen Sie die Standardabweichung; ganze Zahl n; text(1,'Anzahl der Zahlen:'); n:=lesen(1); Kommentar starten Die Variablen werden nur im inneren Block deklariert, da sie vorher nicht benötigt werden; echtes Array a[1:n]; ganze Zahl ich; Real gem,stdev; Durchschnitt:=0; Kommentar Der Durchschnitt wird beim Einlesen berechnet. die Variable av wird für die Summe verwendet; zum ich:=1 Schritt 1 bis um nein tunloslegen       text(1,'Zahl'); schreiben(1,i); Text 1,':'); a[i]:=lesen(1); Durchschnitt:=Durchschnitt a[i] Ende; Durchschnitt: = Durchschnitt/n; Kommentar Die gespeicherten Werte werden für Standardabweichungsberechnungen verwendet; stdev:=0; zum ich:=1 Schritt 1 bis um nein tun       stdev:=stdev(a[i]-avg)^2; stdev:=sqrt(stdev/n); Kommentar Jetzt kommt die Ausgabe; text(1,'Durchschnitt='); rwrite(1,avg,10,6); text(1,' Standardabweichung='); rwrite(1,stdev,10,6) EndeEnde


Auf einem DOS-Bildschirm sehen Ein- und Ausgabe so aus

Anzahl der Zahlen:4Zahl 1 :100001Zahl 2 :100002Zahl 3 :100003Zahl 4 :100004Mittelwert= 100002.48 Standardabweichung= 1.118034

Benutzen

Algol 60 wurde unter anderem an der Technische Universität Eindhoven wo einer der Gründer von Algol 60, Edsger Dijkstraße, war der erste Informatikprofessor. Anfangs ist die X8 verwendet, für die Dijkstra und seine Mitarbeiter selbst ein Betriebssystem und einen Algorithmus-Compiler geschrieben haben. Später a Burroughs Computer, daher die Implementierung von Algol 60 auf dem Burroughs-Mainframe BEATHE nannte sich, Burroughs Extended Algol TH Eindhoven. Algol 60 war auch auf dem TH Delft, das TH Twente und mehrere Universitäten, darunter die von Führen, die Sprache, in der die Schüler ihren ersten Programmierunterricht erhielten. Die Programme waren Lochkarten oder Lochstreifen importiert und der Export war mit Regulierungsdrucker gedruckt. Der BEATHE-Compiler war eine Variante des standardmäßigen Burroughs Extended ALGOL-Compilers. Symbole in BEA sind für den Compiler als reservierte Symbole ('reservierte Wörter') erkennbar. Das Wort INTEGER ist Teil der Syntax und sollte vom Programmierer nicht verwendet werden. In BEATHE werden diese reservierten Symbole zwischen Apostrophen platziert. Die Deklaration 'INTEGER' INTEGER; in BEATHE völlig legal und eindeutig ist, erzeugt es in BEA einen Syntaxfehler. Übrigens wurde die Verwendung von Apostrophen zum Markieren von Symbolen bereits in . verwendet SATHE, eine ziemlich saubere Implementierung von Algol 60. BEATHE kannte auch die Typen STRING und COMPLEX. Der Typ COMPLEX war für viele Anwender ausschlaggebend, ein Programm in BEATHE zu schreiben. Das Eintippen von Apostrophen wurde auf die Linie gelegt. Denken Sie daran, dass bei der Verwendung von BEATHE die meisten Programme auf Lochkarten getippt wurden, BEATHE wurde ausgemustert, nachdem BEA die Typen COMPLEX und STRING übernommen hatte.

Nachfolger

Aus Algol 60 sind eine Vielzahl von Sprachen hervorgegangen. Zur Algol-Familie gehören:

Darüber hinaus sind Programmiersprachen wie fortran, Basic und COBOL viele Elemente aus Algol 60.

Siehe auch

Externe Links