struct X { int a; int f(); };
void foo(int X::*) {}
template<typename T, typename C> void foo2(T C::*) {}
void bar()
{
    foo(&X::a);
    foo2(&X::a);
    foo(&X::f);         // geht schief
    foo2(&X::f);        // sollte auch schiefgehen, tut es aber nicht
}

Eigentlich erwarte ich, dass der Compiler hier ein Problem wie angegeben findet. Visual C++ 2005 und Comeau C++ sind da allerdings anderer Meinung. Gibts einen anderen Weg der Deklaration (d.h. ohne noch eine Überladung für Memberfunktionen anbieten zu müssen oder etwas anderes Umständliches - das wäre ja kein Problem), so dass die Funktion wirklich nur für Zeiger auf Member existiert?

struct X
{
	int f(){return 42;}
};

template<typename T, typename C> void test(T C::*)
{
	printf("T: %s\n", typeid(T).name());
} 

int main() 
{ 
    test(&X::f);        // passt schon so, ist nur aufn ersten blick nicht erkennbar wenn man noch nicht weiss was passieren wird
}

der sagt bei hustbaers beispiel:

test.cpp:17: error: no matching function for call to `test(int (X::*)())'

ich vermute hier eine nonstandard extension beim vc

Der gcc frisst das zumindest nicht.

der sagt bei hustbaers beispiel:

test.cpp:17: error: no matching function for call to `test(int (X::*)())'

ich vermute hier eine nonstandard extension beim vc

Das hatte ich auch gedacht (eher ein Compilerbug - denn Erweiterungen hab ich abgeschaltet) aber auch der Online Comeau Compiler nimmt es in allen Versionen. Es ist auch recht nutzlos, denn mit dem übergebenen Pointer selbst kann ich nicht sinnvoll weiterarbeiten. Es wird noch besser:

foo2<int>(&X::f);
    foo2<int,X>(&X::f);

werden beide abgelehnt. Scheint also doch ein Bug sein.

Verstehe nämlich die Syntax und deren Zweck nicht.

Was soll denn dieser Code bewirken?
Habe mir das Beispiel gebastelt.

struct Test
{
   int a;
   void f();
};

void foo(int Test::* b) // was ist denn das für ein Paramter????
{
   std::cout << b;
}

int _tmain(int argc, _TCHAR* argv[])
{
   foo(&Test::a);
}

Bei mir kommt 1 raus ???

foo2<int(),X>(&X::f);

heißen und das funktioniert dann auch. Muss ich für meine Zwecke eben doch nochmal nur für Zeiger auf Memberfunktionen spezialisieren. Es gibt ja einen ähnlichen Fall, wo ein einfacher Funktionstyp für Memberfunktionen benutzt wird:

typedef void foo();
struct X {
    foo bar; // deklariert die nichtstatische Memberfunktion void X::bar()
};

sehr unintuitiv - imo hätte man das anders lösen sollen.

man nutzt den zeiger eigentlich für sowas:

template<class Class, class Type>
void foo(const Class& object,int Class::* memberpointer)
{
     std::cout<<object.*memberpointer;
};

struct Test
{
    int bar;
};

int main()
{
    Test test;
    test.bar=35;
    foo(test,&Test::bar);
};

dein

foo(&Test::a);

ist daher so etwas wie:

std::cout << (&Test::a != 0);

und da kommt natürlich true (1) heraus.