Information Technology Reference
In-Depth Information
Funktionale Sprachen
Generell kann man Programme als Funktionen im mathema-
tischen Sinne deuten, durch die Eingabedaten in Ausgabeda-
ten abgebildet werden. Bei den prozeduralen Sprachen, wie
FORTRAN, PASCAL oder C, die entscheidend durch die von
Neumann-Rechnerarchitektur geprägt sind, lassen sich die
einzelnen Konstrukte eines Programms selbst jedoch nicht
als Funktionen über einfachen Bereichen deuten. Ihre Bedeu-
tung ist von dem Begriff der Adresse eines Speicherplatzes
abhängig und von der Vorstellung einer sequenziellen Pro-
grammausführung geprägt.
Betrachtet man zwei Funktionen
f, g,
die ganze Zahlen in
ganze Zahlen abbilden, so
gilt das Kommutativgesetz
tert. C++ weist in Bezug auf Entwicklungsgeschwindigkeit,
Wartbarkeit und Abstraktionsniveau deutliche Verbesserun-
gen gegenüber C auf.
Die Entwicklung erfolgte durch
Bjarne Stroustrup
(* 30. Dezember 1950 in Aarhus, Dänemark), der ab 1982/83
grammieren mit
Simula
erlernt hatte und bei seinem späteren
Arbeitgeber AT&T in C programmieren musste, reicherte er
C mithilfe eines Präprozessors (cfront) um die wesentlichen
Konstrukte von Simula an, um weiter in der erlernten Art
programmieren zu können. Seine Erweiterung hieß zunächst
C with classes
und danach C++.
Abb. 2.21
Bjarne Stroustrup
f
(
a
)
+
g
(
a
)
=
g
(
a
)
+
f
(
a
)
.
Wegen der Seiteneffekte, die durch die Wertzuweisungen
bewirkt werden, gilt dieser einfache Sachverhalt nicht bei
prozeduralen Sprachen, d. h. „functions“ in PASCAL verhal-
ten sich z. B. nicht wie mathematische Funktionen. Dies zeigt
das folgende PASCAL-Programm:
Zusätzlich zu den in C vorhandenen Möglichkeiten bot
C++ weitere Datentypen und Klassen mit Vererbung, virtuel-
len Funktionen, Ausnahmebehandlung, Templates, Referen-
zen, die Möglichkeit von Kommentaren (die ans Zeilenende
gebunden waren), Freispeicherverwaltung und die C++-Stan-
dardbibliothek. Im Jahre 1989 erschien die Version 2.0 von
C++. Neu darin waren Mehrfachvererbung, abstrakte Klas-
sen, statische Elementfunktionen, konstante Elementfunktio-
nen und die Erweiterung des Schutzmodells um „protected“.
Durch die Abwärtskompatibilität zu C hat C++ allerdings
auch das Manko, einen großen „historischen Ballast“ mit sich
zu führen, so zum Beispiel der von C übernommene Präpro-
zessor oder die teilweise schwer verständliche C-Syntax. Die
Kompatibilität zu C hat u. a. zur Folge, dass einige Details
der Sprache compilerspeziisch sind, die es aber nicht sein
müssten. Dies erschwert die Portierung von C++-Program-
men zwischen Rechnertypen, Betriebssystemen und unter-
schiedlichen Compilern.
program P (output);
var a : integer;
function f (x : integer) : integer;
begin a :=
x
+
1; f
:=
a end;
function g(x : integer) : integer;
begin a :=
x
+
2;
g
:=
a end;
begin
a :=
0;
write(f (a)
+
g(a));
a :=
0;
write(g(a)
+
f (a));
end;
Man erhält verschiedene Ausgaben:
f
(
a
)
: a
=
1,
f
(
a
)
=
1
g
(
a
)
: a
=
3,
g
(
a
)
=
3
f
(
a
)
+
g
(
a
) = 1 + 3 = 4
bzw.
Beispiel
in C
g
(
a
)
: a
=
2
,
g
(
a
)
=
2
#include <stdio.h>
int main (void)
{
printf(“Hallo Welt!\n”);
return 0;
}
f
(
a
)
: a
=
3
,
f
(
a
)
=
3
f
(
a
)
+
g
(
a
) = 2 + 3 = 5
Der Funktionswert
f
(
a
) ist also abhängig von seinem Vor-
kommen im Programm. Bei einer mathematischen Funktion
bezeichnet
f
(
a
) jedoch stets denselben Funktionswert. Weiter-
hin hat man in der Mathematik eine konsistente Benutzung
von Namen. Die Gleichung
Beispiel
in C++
#include <iostream>
int main()
{
std::cout << “Hallo Welt!” << std::endl;
x
2
−
2
x
+
1
=
0