objektorientierung/überladen



  • hi,

    kurze frage: gibt es eine oo-sprache in der methoden über den rückgabewert überladen werden können??

    also a la:

    void meth(int a){...}
    int meth(int a){...}

    und jetzt hab ich zwei verschiedene Methoden. dass es über übergabeparameter geht ist mir schon klar, aber gibts sowas?

    danke



  • int foo();
    double foo();
    
    void bar(int i);
    void bar(double d);
    
    int main()
    {
        bar( foo() );
    }
    

    das wäre das problem in c++, aber ich denke ander sprachen werden auch das problem haben



  • also ich entnehme deiner antwort, dass es also möglich ist in c++ methoden über die definition des rückgabewertes zu überladen.
    in java dürfte das (laut java in a nutshell) nämlich nicht möglich sein.

    was macht dann eigentlich dein beispielcode......ist der lauffähig, da ja zweideutig....also methode kann ja nicht eindeutig identifiziert werden.

    oder hab ich alles falsch verstanden, und du wolltest mir mit deinem beispiel zeigen, dass es nicht möglich ist.



  • in Ada95 geht das, afaik



  • hast du irgendwas an der hand wo dass so drinnen steht......müsste das belegen können. hab gerade mal schnell im netzt gesucht, und diesbezüglich nichts gefunden. .....und nen adacompiler hab ich gerade nicht da um es auszuprobieren.
    falls es ging.....wie schützt sich dann ada gegen dass was von dimah in c++ geschrieben wurde??
    danke



  • Hi !

    Es wäre unlogisch wenn das ginge.

    Denn :

    int foo()
    {
        cout << "hello world\n";
        return PI;
    }
    std::string foo()
    {
         cout << " :xmas1: ";
         return "hohoho";
    }
    
    int main()
    {
         //mmmh ? was jetzt ?
         foo ();
    }
    


  • Hallo,
    C++ kann's, templates (und PAINAE-Prinzip) sei dank, aber nur solange du die Funktionen nicht aufrufst 🙂



  • Na ganz einfach:

    with Ada.Text_IO;
    use Ada.Text_IO;
    
    procedure Overload is
       function Foo return Integer is
       begin
          Put_Line("Integer");
          return 42;
       end Foo;
       function Foo return Character is
       begin
          Put_Line("Character");
          return 'x';
       end Foo;
    
       A: Integer;
       B: Character;
    begin
       A := Foo;
       B := Foo;
    end Overload;
    

    Ausgabe:

    Integer
    Character
    


  • @bashar:

    und was passiert wenn du nur

    Foo;

    schreibst....oder ist das in Ada nicht möglich???



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

    Genau. Dafür gibts Prozeduren.



  • 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() );
    }
    


  • 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. ]



  • 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



  • 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.



  • 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. ]



  • 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)?



  • 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?



  • [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.


Log in to reply