wäre es eigentlich --- rein theoretisch! --- möglich, C++ zu einer
dynamisch getypten Sprache zu machen, also zu einer Sprache, in der man
zur Compile-Zeit keinerlei Typangaben zu machen braucht ?

Ich stelle mir das so vor: Eine Klasse "Object", von der *alle* anderen
Klassen (inkl. Zahlen, Strings, Files,...) Unterklassen sind
(soll heißen: alle Klassen sollen von der Klasse "Object" erben).
Dann könnte man doch die Typangaben aller Funktionen und Methoden durch die Typangabe "Object" ersetzen, und könnte theoretisch jede Funktion mit jeder beliebigen Sorte von Objekt als Argumente aufrufen, da ja jede Klasse Unterklasse von "Object" wäre, also jedes Objekt zur Typangabe "Object" paßt.
Der Compiler dürfte dann doch nie meckern.

Ob die Parameter dann zur Funktion passen oder nicht (d.h. ob die
Objekte passende methoden anbieten, wie sie in der Funktion aufgerufen werden
oder nicht), stellt sich dann erst zur Laufzeit heraus.
Im Ergebnis entspräche das doch dem "Duck Typing", wie es in Ruby und anderen
dynamisch getypten Sprachen stattfindet: kein Typcheck zur Compilezeit.

Natürlich müßte man dann alle Libraries umschreiben, sodaß Zahlen und
String und Files, Felder und Listen etc. alles Unterklassen von "Object" sind, aber davon mal abgesehen, und davon, ob der Aufwand vernünftig ist oder nicht:
Ginge das prinzipiell ? Wäre dann C++ wie eine dynamisch getypte Sprache
verwendbar ?

Beispiel:
Object main(Object c, Object v) {
cout << "Anzahl Argumente:" << c << endl ;
Object n ;
n = 3 ;
n := n * 2 ;
cout << "2*3=" << n << endl ;
}

vector<Object> v ;
v.push_back("hallo");
v.push_back(3);

also eine Liste aus Objekten verschiedener Art. Ganz ähnlich wie in Perl,Python,Smalltalk,Ruby und Co.
Wäre doch vielleicht die Mühe des Umschreibens der Includes wert?

machbar wär das grundsätzlich schon, wie du schon selbst sagst über die Objektvererbung. Doch ich denke da werden auch einige der C (++) Besonderheiten dabei draufgehen, zum Beispiel eben genau die Typkontrolle. Außerdem vergißt du das die dynamsiche Typüberprüfung bzw. RTTI eben Laufzeit kostet.
In C++ verwendet man dafür auch Templates, um eingeschränkte Typfreiheit zu bekommen.

bis bald
akari

akari:

Die Typkontrolle geht weg, da hast Du vollkommen Recht - das ist dann eben das neue "Feature", denn die (zur Compile-Zeit) fehlende Typkontrolle sorgt
ja in den (im Augenblick sehr in Mode geratenen) dynamisch getypten Sprachen für den lockeren "Rapid Prototyping" - Programmierstil, bei dem man zur Compile-Zeit keine Typen angibt, was dem
Programmierer einiges an Arbeit spart.
Natürlich kann man dann unangenehme
Überraschungen zur Laufzeit erleben, wenn eine Funktion auf ein Objekt angewandt
werden soll, das die gefragte Methode nicht liefert. Es liegt dann am
Programmierer, das Risiko zu begrenzen.

Tobias W:

Ich meine ja nicht, daß C++ immer so verwendet werden sollte wie beschrieben.
Ich finde aber, daß man auf diese Weise eine Sprache hätte, bei der man
bei Bedarf (wenn man auf Typsicherheit und Performance Wert legt)
die Typen zur Compilezeit festlesgen kann, und wenn das nicht nötig
ist (s. Rapid Prototyping) könnte man "dynamisch" typen und beide Formen
mischen, sodaß performance-kritische Routinen statisch getypt werden und
z.B. das GUI ohne Typangaben programmiert wird, was Programmierzeit spart
und das Programm verkürzt.

Wenn das wirklich ginge, könnte man bei Bedarf C++ ähnlich wie
Python oder Ruby benutzen, allerdings wohl nicht ganz genauso: bei
der Verwendung von Funktionen oder Funktionszeigern als Argumente für
Funktionen müßte man in C++ trotz "class Object" noch die Anzahl
Argumente vor dem Aufruf festlegen, d.h. eine Funktion vom Typ Object f(Object, Object)
wäre nicht übergebbar als Argument, wenn eine Funktion vom Typ Object f(Object) verlangt ist.
Das ließe sich vermutlich nur lösen, wenn auch Funktionen in C++ Objekte
wären, und das ist vermutlich schwieriger oder unmöglich zu machen, ohne
die Sprachspezifikation zu ändern, denn letztendlich müßte man dann
einen "alles ist ein Objekt"-Ansatz in C++ realisieren, und das scheint
mir doch im Moment ein wenig "Science-Fiction" zu sein.

Grüße

abgesehen von dem, was hier schon geschrieben wurde: C++ *hat* Duck Typing! Sonst würde folgender Code nicht funktionieren:

template <typename T>
void times_two(T& x) { x *= 2; }

Es ist statisch, aber das macht es nicht weniger zu Duck Typing. Es geht halt nur für generische Typen.

Danke für den Hinweis!

Beste Grüße.