Newsgroup: it.comp.lang.c++
Titolo: Problema con puntatori a funzione

Ciao a tutti.
Ho un problema che descrivo di seguito....
- c'e' una classe di una vecchia libreria che richiede un puntatore a
funzione nel costruttore.
	class A {
			public:
				A(double (*)(double));
			...
		};
- vorrei riuscire a creare un oggetto di tipo A passandogli come
parametro un metodo virtuale di un'altra classe.
	Esempio:
		class AbsB {
			A pippo; 
			...
			public:
				virtual double f(double) = 0;
			...		
		};
		class concrB: public AbsB {
			...
			public:
				ConrB(): pippo(&(this->f)) {...};//SO CHE NON SI PUO' FARE MA E' PER
RENDERE L'IDEA!!!!
				virtual double f(double t) {....};
		};
 
-- 	
 ("`-''-/").___..--''"`-._                  Luigi Palopoli
   `6_ 6  )   `-.  (     ).`-.__.`)          Phd Student
   (_Y_.)'  ._   )  `._ `. ``-..-'      Scuola Superiore S. Anna
 _..`--'_..-_/  /--'_.' ,'               Via Carducci 40 - 56100
(il),-''  (li),'  ((!.-'                    Pisa - Italy
                                   Tel. 
+39-050-883444
 Fx 
+39-050-883452
					emaili: 
palo...@sssup.it

 parametro un metodo virtuale di un'altra classe.
Non puoi.  Se richiede un puntatore a funzione, devi darle
un puntatore a funzione, NON un puntatore a metodo (virtuale
o meno), che d'altra parte non sarebbe chiamabile senza
un puntatore-ad-oggetto che lo accompagni, e che ahime`
l'architettura della vecchia libreria non ti da la chance
di salvare o passare da nessuna parte).
Alex (MVP di Brainbench per il C++)

 di salvare o passare da nessuna parte).
nelle ATL (dove questo problema salta fuori perchè WNDCLASS::lpfnWndProc è un puntatore a funzione) hanno risolto scrivendo una
thunk in ASM (credo anche MFC funziona con lo stesso meccanismo).
se serve a qualcuno posto il codice.
ciao
xaero

nelle ATL (dove questo problema salta fuori perchè WNDCLASS::lpfnWndProc è un puntatore a funzione) hanno risolto scrivendo una
Potresti scrivere i tuoi messaggi con righe di max 70 caratteri ?
--
Walkie...@Libero.It (ICQ# 8143647)

 ha scritto nel messaggio
news:3b147c99...@news.libero.it...


di salvare o passare da nessuna parte).
E' vero che il codice qua sotto č un mostro di design, usa variabili
globali, č molto soggetto ad errori, ecc. Perň dovrebbe funzionare
almeno il necessario per fare quello che Luigi chiede:
#include <iostream>
class A {
  int i;
public:
  A(int ii): i(ii) { }
  void f() { cout << i << endl; }
};
typedef void (*ptrF)();
void call_ptrF(ptrF p){ p(); }
A* ptrA;
void wrapper_f() { ptrA->f(); }
int main() {
  A a(3);
  ptrA=&a;
  call_ptrF(wrapper_f);
}
Naturalmente bisogna stare molto molto attenti a quello che si fa, in
quanto č facilissimo commettere errori. Inoltre si potrebbe anche
generalizzare l'esempio per permettere di usare piů funzioni wrapper_f
associate a diverse istanze di A:
A* ptrA[10];
template<int i> void wrapper_f() { ptrA[i]->f(); }
ecc.ecc.
Anto
PS: vi prego, non uccidetemi per quest'obrobrio ;-)
--
Antonio Cuni, 19 anni, studente
Brainbench Certification: 
Master C++: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
http://www.brainbench.com/transcript.jsp?pid=1301688

Il problema potrebbe essere risolto se il metodo della classe venisse definito
static.
Ivan Molella
-- 
Posted from 
relay.iunet.it
 [192.106.1.2] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

Non si puo fare neanche con un membro static,non avevo letto che il il membro doveva essere virtual.


>Non si puo fare neanche con un membro static,non avevo letto che il il membro doveva essere virtual.
e, cosa ancora peggiore, richiede di modificare il design della classe
già creata... non sempre è possibile farlo
Anto


 ha scritto nel messaggio
news:9e3dic$mip$1...@serv1.iunet.it...

Meglio dire che il C++ non te lo permette direttamente.
Con un poco di impegno, tuttavia, č possible raggiungere lo scopo.
Ad esempio ho implementato una funzione (ed una classe di supporto)
    template<class Obj, class Res, class Arg>
    class unary_fun_t
    template<class Obj, class Res, class Arg>
    unary_fun_t<Obj, Res, Arg> unary_fun(Obj* o, Res (Obj::*m)(Arg))
che permette di fare (in modo safe, o almeno spero :-):
class concrB: public AbsB
{
    // ...
    public:
        ConcrB()
        : pippo(unary_fun(this, &concrB::f) { }
        virtual double f(double t) {....};
};
L'implementazione č piuttosto lunga e, vista anche la data non recente
del messaggio, evito di postarla.
Se a qualcuno interessa (il tutto č in ANSI C++)...
Saluti   Manlio Perillo