willstenoch erläuterungen dazu?

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

Gruß
Werner

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

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?

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.

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ß

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

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