objektorientierung/überladen

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.

Bashar

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

Headhunter

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

HumeSikkins

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

Bashar

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

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.