Newsgroup: it.comp.lang.c++
Titolo: Puntatori a funzioni membro

Ciao a tutti, ho la necessità di creare un puntatore a funzione che sia
membro di una classe, e poi fare in modo che esternamente questo puntatore
venga assegnato di volta in volta alla funzione giusta...esempio:
class MyClass{
	int (*myfunc)();	// E'corretto questo???
};
int prova();
int main(){
	MyClass *p=new MyClass();
	// Come faccio ad assegnare a myfunc di p la funzione prova?
}
Grazie per l'attenzione e chiedo scusa se non sono stato molto chiaro
(sono le 2:20...abbiate pietà! :-) )

 }
Nel caso specifico non puoi, perche' MyClass non ha una funzione
membro prova e perche' myfunc e' privato. Comunque:
struct S {
  int f();
  int (S::*myfunc)();
};
int S::f() { return 0; }
int main() {
  S s;
  s.myfunc = &S::f;
  return (s.*s.myfunc)();
}
Ciao,
Nicola

 }
MMMh, il puntatore a funzione non e' un costrutto comunissimo da usare 
in C++, in quanto spesso quello che in C si fa coi puntatori a funzione 
in c++ si fa con l'ereditarieta', inoltre da quello che ho capito tu 
vuoi utilizzare una funzione globale, quindi non ti interessa il 
contenuto del "this". In tal caso puoi fare per esempio cosi':
class MyClass {
public:
	MyClass(myfuncptr p) : ptr(p) {}
	typedef int (*myfuncptr)();
	int func() { return ptr(); }
private:
	myfuncptr ptr;
};
int prova();
int main() {
	MyClass *p = new MyClass(prova);
	p->func();
}
... detto cio' aggiungo che mi pare non troppo utile a prima vista, ma 
magari ho capito male io il tuo scopo :)
Bye,
  Gabry

   Gabry
Quello che vorrei è poter sostituire a runtime una funzione, ad esempio
avere una serie di oggetti (dello stesso tipo, senza usare ereditarietà)
MyClass a;
MyClass b;
MyClass c;
e poter associare ad ognuno di questi una funzione diversa...esempio
int funzione1();
int funzione2();
a.myfunc=&funzione1;
b.myfunc=&funzione2;
c.myfunc=&funzione1;
in modo da poter chiamare per a,b o c sempre myfunc ed ottenere un
risultato diverso. Lo so che il metodo classico per risolvere questo
problema è derivare 3 classi diverse per i tre oggetti e ridefinire un
metodo virtuale, tuttavia a me servirebbe usare la stessa classe, e in
più poter decidere a runtime quale funzione associare ad ogni oggetto...
Altra idea, se usassi delle funzioni oggetto?

 più poter decidere a runtime quale funzione associare ad ogni oggetto...
In questo caso non ti serve un puntatore a funzione membro, ma un
membro puntatore a funzione (e' chiaro o devo riscriverlo con le
parentesi? ;-)
struct MyClass {
  int (*myfunc)();
};
int funzione1() { return 1; }
int main() {
  MyClass a;
  a.myfunc = funzione1;
  return (a.myfunc)();
}
Ciao,
Nicola

La soluzione l'hai già data tu... non funziona questo?
class MyClass{
public:
int (*myfunc)();
};
int prova1 () {
cout << "Prova1 !"<<endl;
return 0;
}
int prova2 () {
cout << "Prova2 !"<<endl;
return 0;
}
int main()
{
 MyClass *p1=new MyClass();
 p1->myfunc = prova1;
 p1->myfunc();
 MyClass *p2=new MyClass();
 p2->myfunc = prova2;
 p2->myfunc();
 getchar();
 return 0;
}

 
Questo si...mi sono spiegato un po'da cane...QUESTO non funziona:
MyClass{
	public:
		int (*myfunc) ();
};
MyAltra{
	public:
		int prova(){ cout<<"Prova"<<endl;}
		void qualcosa();
};
void MyAltra::qualcosa(){
	MyClass *a=new MyClass;
 
	a->myfunc=prova;
}
Output di g++:
myaltra.cpp:19: no matches converting function `prova' to type
`int (*)()'
myaltra.h:22: candidates are: int myaltra::prova()
Dipende dal fatto che sono due classi differenti?

 Dipende dal fatto che sono due classi differenti?
Una member function non ha un function pointer valido, o meglio, puo' 
averlo se la metti static, ma perdendo l'accesso ai dati non statici 
della classe.
Quello che hai fatto puoi funzionare quindi solo se la funzione 
"sorgente" e' globale o e' una member function statica.
Bye,
  Gabry

   Gabry
Era quello che immaginavo in effetti...grazie per la risposta...

> Era quello che immaginavo in effetti...grazie per la risposta...
Purtroppo questo è un vincolo nel caso tu voglia assegnare un puntatore a
membro funzione ad un membro di una classe.
Però se il problema è l'esecuzione in runtime di una funzione tramite il suo
puntatore, guarda questo esempio:
class MyClass{
public:
 MyClass() {val = 0;}
 int val;
 int somma(int lval) {
  val+=lval;
  cout <<"val = "<<val<<endl;
  return 0;
 }
 int sottrai(int lval) {
  val-=lval;
  cout <<"val = "<<val<<endl;
  return 0;
 }
};
class MyAltra{
public:
 int (MyClass::*func)(int);
 MyClass a;
 void qualcosa (int q){
  if (q==1)
   func = &MyClass::somma;
  else
   func = &MyClass::sottrai;
  (a.*func)(3); //questa funzione esegue il metodo scelto a runtime tramite
puntatore a membro (funzione)
 }
};
int main()
{
 MyAltra c;
 c.qualcosa(1);
 c.qualcosa(2);
    return 0;
}