eine Idee (rückgabetyp pseudoüberladen)

davie

wegen des operator& beitrags weiter unten ist mir folgende idee gekommen:

template <class T, class U> 
struct derived_type {
//stellt fest, ob T eine basisklasse von U ist
    struct inner {
        typedef char yes;
        struct no { char dummy[2]; };
        static yes check (const volatile U *);
        static no check (...);
    };
    enum {value= 
            (sizeof(inner::check((T*)0)) == sizeof(typename inner::yes))
         };
};

class return_helper {}; //dummy klasse um festzustellen, ob 2.param extra behandelt werden muss:

template <class A, class B, bool C = derived_type<B, return_helper>::value>
class return2 : public return_helper {
    A a; B b;
public:
    return2 (A a_, B b_) : a(a_), b(b_) {}
    template <bool X>
    return2 (const return2<A,B,X> &r) : a(r.a), b(r.b) {}
    operator A () { return a; }
    operator B () { return b; }
};

template <class A, class B>
class return2<A, B, true> : public B {
    A a;
public:
    return2 (A a_, B b) : B(b), a(a_) {}
    operator A () { return a; }
};
//helfer funktion zum leichterschreiben
template <class A, class B>
return2<A,B> re (A a, B b) {
    return return2<A,B> (a,b);
}

//Zum Austesten:
return2<int, return2<double, return2<float, return2<long, char> > > >
foo () {
    return re(42, re(24.42, re(float(1.2), re(long(88), 'a'))));
}

int main () {
    //Tadamm: darauf läuft es hinaus:
    int i = foo();
    double d = foo();
    float f = foo();
    long l = foo();
    char c = foo();

}

und endlich ist man das problem los, eine funktion nach ihrem rückgabetyp nicht überladen zu können (obwohl überladen hier eigentlich nicht mehr ganz passend ist)

code ist schnell zusammengeschrieben und nur einmal kurz getestet, also etwas nachsichtig sein.
seht es als spielerei, von der ich wissen will, wie sie euch gefällt

Mr. N

lustig isses. ich persönlich finde aber int i = foo<int>(); schöner

volkard

gefällt mir gut.

HumeSikkins

Hallo,
hm, scheinbar habe ich heute schon zu lange auf C++ Code gestart. Wo ist denn hier die Überladung?

Sollte Überladung nach Rückgabetyp nicht mehr so aussehen:
Funktionen nach Rückgabetyp überladen

Also zwei oder mehr Funktionen mit dem selben Namen die sich nur im Rückgabetyp unterscheiden.

volkard

Original erstellt von HumeSikkins:
Hallo,
hm, scheinbar habe ich heute schon zu lange auf C++ Code gestart. Wo ist denn hier die Überladung?

ist keine. fühlt such nur so an. dein code (danke für den link, der trick war mir neu) ist viel besser. ich freu mich schon drauf, wenn ich mal nen compiler hab, der es schluckt.

davie

sagte ich nicht 'pseudo'?
solange mein gcc rückgabewerte von templatefunktionen nicht mit für signatur einbezieht, geht sowas auch noch:

template <class T>
T foo_impl ();

template <>
int foo_impl<int> () { return 0; }

template <>
double foo_impl<double> () { return 1; }

struct foo {
    template <class T>
    operator T () {
        return foo_impl<T>();
    }
};

int main () {  

   int i = int(foo());
   double d = double(foo());

}

dann ist mein workaround wohl mehr eine erweiterung von std::pair

HumeSikkins

sagte ich nicht 'pseudo'?

Das war kein Angriff. Ich habe deinen Code im Zusammenhang mit Überladung nicht verstanden und ich verstehe ihn nach wie vor nicht.

Das liegt wahrscheinlich daran, dass ich nicht weiß, was genau du mit "Pseudo" meinst.

Naja, war ja nur ne Frage