Beispiel für .* und ->*

Kann mir jdm nen Beispiel machen, das die beiden Operatoren verwendet?

class cppboard
{
    public:
        int member,trolle;
        cppboard() : member(5000) , trolle( 4990 )
            {}
};

int main()
{
    cppboard rudp,
             nadrw,
             *pointer = &nadrw;
    std::cout << rudp.trolle << " " << nadrw.trolle << " " << pointer -> trolle;
    pointer = &rudp;
    std::cout << " " << pointer -> trolle ;
}

willstenoch erläuterungen dazu?

Werner Salomon

struct Foo { 
    void machwas() { std::cout << "machwas"; }
    void was_anderes() { std::cout << "was_anderes"; }
};
typedef void (Foo::*pMethode_von_Foo)();
void work( Foo& foo, pMethode_von_Foo methode )
{
    (foo.*methode)(); // <-- hier
}

int main()
{
    pMethode_von_Foo m1 = &Foo::machwas; // oder &Foo::was_anderes
    Foo foo;
    work( foo, m1 );
    return 0;
}

Falls Du in work das Objekt 'foo' per Pointer übergibst, so benötigst Du den ->*-operator.

Gruß
Werner

b.s.p. schrieb:

class cppboard
{
    public:
        int member,trolle;
        cppboard() : member(5000) , trolle( 4990 )
            {}
};

int main()
{
    cppboard rudp,
             nadrw,
             *pointer = &nadrw;
    std::cout << rudp.trolle << " " << nadrw.trolle << " " << pointer -> trolle;
    pointer = &rudp;
    std::cout << " " << pointer -> trolle ;
}

willstenoch erläuterungen dazu?

wenn man keine ahnung hat, einfach mal die fresse halten

Werner Salomon schrieb:

struct Foo { 
    void machwas() { std::cout << "machwas"; }
    void was_anderes() { std::cout << "was_anderes"; }
};
typedef void (Foo::*pMethode_von_Foo)();
void work( Foo& foo, pMethode_von_Foo methode )
{
    (foo.*methode)(); // <-- hier
}

int main()
{
    pMethode_von_Foo m1 = &Foo::machwas; // oder &Foo::was_anderes
    Foo foo;
    work( foo, m1 );
    return 0;
}

Falls Du in work das Objekt 'foo' per Pointer übergibst, so benötigst Du den ->*-operator.

Gruß
Werner

Danke.

Habe gehört man könnte diese beiden operatoren auch überladen, wie würde das dan aussehen?

camper

nur ->* kann überladen werden, ich habe allerdings das allerdings noch nie gesehen. der standard enthält keine passage, die auf besonderheiten beim überladen hinweist, es ist also ein ganz normaler binärer operator, der auch als freie funktion implementiert werden kann (es ist also etwas völlig anderes als operator->). Eine überladung, die dem ursprünglichen sinn dieses operators nahekommt, ist schwer vorstellbar - und anderen zwecken dürfte die hohe priorität des operators entgegenstehen (sonst könnte man sich z.b. vorstellen, den iostream operator >> durch diesen operator zu ersetzen). die signatur des eingebauten operators ist in 13.6/11 zu finden:

For every quintuple (C1, C2, T, CV1, CV2), where C2 is a class type, C1 is the same type as C2 or is a derived class of C2, T is an object type or a function type, and CV1 and CV2 are cv-qualifier-seqs, there exist candidate operator functions of the form
CV12 T& operator->(CV1 C1, CV2 T C2::*);
where CV12 is the union of CV1 and CV2.

wenn du lust hast, kannst du daraus ja einen potenz operator machen (der hätten dann die richtige priorität). leider aber nur, wenn wenigstens ein argument ein UDT ist.

FireFlow

camper schrieb:

wenn du lust hast, kannst du daraus ja einen potenz operator machen (der hätten dann die richtige priorität). leider aber nur, wenn wenigstens ein argument ein UDT ist.

Würde ich nicht machen, das sieht dem Code keiner an das da potenziert wird. Da liest sich ein pow viel schönerm egal ob man dadurch paar Zeichen mehr schreiben muss.

Gruß

CV2 T C2::*
Das ist doch nen Member-Function-Ptr oder?

Also kann man op->* nicht sinnvoll überladen, wie zB op++

camper

FireFlow schrieb:

camper schrieb:

wenn du lust hast, kannst du daraus ja einen potenz operator machen (der hätten dann die richtige priorität). leider aber nur, wenn wenigstens ein argument ein UDT ist.

Würde ich nicht machen, das sieht dem Code keiner an das da potenziert wird. Da liest sich ein pow viel schönerm egal ob man dadurch paar Zeichen mehr schreiben muss.

Gruß

ich meinte auch nicht, dass man es tun sollte, es war nur eine möglichkeit. letzlich ist es sowieso nur eine frage der konvention - ich könnte auch behaupten, dass es ganz und gar nicht offensichtlich ist, was << und >> mit streams anstellen - oder z.B. % mit boost:format objekten.

Bsp schrieb:

CV2 T C2::*
Das ist doch nen Member-Function-Ptr oder?

Also kann man op->* nicht sinnvoll überladen, wie zB op++

obige deklaration ist die signatur des eingebauten operators. jede überladung muss folglich davon abweichen. nehmen wir das potenzbeispiel:

#include <iostream>
#include <cmath>
using namespace std;
struct Double
{
    Double(double v) : v(v) {}
    operator double() const { return v; }
    double v;
};
double operator->*(const Double& base, const Double& exponent)
{
    return pow( base, exponent );
}

int main()
{
    cout << 2.0->*Double(3.0);
}

Beispiel für .* und -&gt;*

Beispiel für .* und ->*