objektorientierung/überladen

Bashar

Original erstellt von <rich>:
oder ist das in Ada nicht möglich???

Genau. Dafür gibts Prozeduren.

Gerard

gehe ich recht in der annahme das ada hier eine fehler meldung brigen würde?

// pseudo ada code ;)
int foo();
double foo();

void bar(int i);
void bar(double d);

int main()
{
    bar( foo() );
}

Bashar

overload.adb:30:04: ambiguous expression (cannot resolve "Bar")
overload.adb:30:04: possible interpretation at line 9
overload.adb:30:04: possible interpretation at line 5
gnatmake: "overload.adb" compilation error

[ Dieser Beitrag wurde am 25.12.2002 um 15:02 Uhr von Bashar editiert. ]

Bashar

Man kann dann übrigens den Typ spezifizieren:

Bar(Integer'(Foo));

Das ist kein Cast, keine Umwandlung, sondern lediglich eine Typfeststellung zur Beseitigung von Mehrdeutigkeiten.

@bashar

sorry, dass ich des jetzt nochmal ausgrab, aber da du deinen quelltext der im vorigen beispielcode stand durch ne fehlermeldung ersetzt hast, schließ ich daraus, dass es wohl in ada auch nicht möglich ist methoden über den rückgabewert zu überladen, right?

fällt sonst noch jemanden irgend eine exotische objektorientierte sprache ein in der das möglich wäre.......wie stehts mit clos.....obwohl.....a propos clos....wie macht man in lisp nochmal nen rückgabewert...oder war das der wert des letzten evaluierten statements?

egal, falls jemanden noch was einfällt, bitte posten

ansonsten nen gutes neues

Bashar

nö falsch geschlossen,
der ada-compiler produziert nur dann ne Fehlermeldung, wenn er, wie bei Dimahs Pseudo-Code nicht zweifelsfrei entscheiden kann, welche der Prozeduren aufgerufen werden soll.
Wenn die Verhältnisse eindeutig sind, gibt es keine Probleme.

Die Frage mit CLOS läßt sich nicht recht sinnvoll beantworten, da Lisp keine statische Typisierung kennt. Überladen (im sinne von statischer Polymorphie wie in Java/C++/...) ist folglich nicht möglich.

Gerard

eigentlich könnte man so was in c++ simulieren, mit ein proxy objekt und den convertierungs operator,

#include <iostream>
using namespace std;

int int_foo()
{
    std::cout << "int\n";
    return 0;
}

bool bool_foo()
{
    std::cout << "bool\n";
    return true;
}

template<int i> 
struct dummyType 
{
};

template<int i>
dummyType<i> dummyFunc()
{
    return dummyType<i>();
}

template
<
    typename T1 = dummyType<1>, T1 (*funcPtr1)() = &dummyFunc<1>,
    typename T2 = dummyType<2>, T2 (*funcPtr2)() = &dummyFunc<2>,
    typename T3 = dummyType<3>, T3 (*funcPtr3)() = &dummyFunc<3>,
    typename T4 = dummyType<4>, T4 (*funcPtr4)() = &dummyFunc<4>,
    typename T5 = dummyType<5>, T5 (*funcPtr5)() = &dummyFunc<5>
>
struct bar
{
    operator T1 ()
    {
        return funcPtr1();
    }

    operator T2 ()
    {
        return funcPtr2();
    }

    operator T3 ()
    {
        return funcPtr3();
    }

    operator T4 ()
    {
        return funcPtr4();
    }

    operator T5 ()
    {
        return funcPtr5();
    }   
};

typedef bar<int, &int_foo, bool, &bool_foo> foo;

void bla(int) {}
void bla(bool) {}

int main()
{
    int i = foo();
    bool b = foo();
    bla( int(foo()) );
    bla( bool(foo()) );
}

[ Dieser Beitrag wurde am 01.01.2003 um 05:18 Uhr von Dimah editiert. ]

Helium

Es gibt viele Sprachen, die das können. AFAIK kann man das in Eiffel auch. In Sather geht's auf jeden Fall. und es gibt bestimmt noch einige weitere.

PS: Warum können das eigentlich nur die Algolabkömmlinge (ADA, Eiffel, Sather)?

Bashar

Eiffel kann's ganz sicher nicht. Sein Schöpfer Bertrand Meyer legt in "Object Oriented Software Construction" äußerst detailliert dar, wieso niemand, der seine sieben Sinne beisammen hat, Überladung von Prozeduren und Funktionen gut finden kann

BTW: Inwiefern sind Eiffel und Ada Algol-Abkömmlinge, C jedoch nicht?

Bashar

[mööp]

[ Dieser Beitrag wurde am 02.01.2003 um 18:34 Uhr von Bashar editiert. ]

naja ich meine direktere Abkömmlinge. Deutlich sichtbare Abkömmlinge oder wie auch immer du es ausdrücken willst. Und ok, dann geht es in Eiffel eben nicht.