Newsgroup: it.comp.lang.c++
Titolo: passaggio funzioni a classi annidate

    PS. Dimenticavo, la funzione deve a sua volta passare la
struttura a una classe annidata dentro la principale. Non credo
faccia differenza ma....meglio specificarlo.

    Salve a tutti,
    Ho il problema di passare una funzione a una classe dentro
un'altra. In pratica è qualcosa di simile (ho replicato esattamente
il mio problema, c'è una struct di passaggio argomenti che
*dovrebbe* essere ininfluente) a quanto più sotto. Il compilatore mi
dà errore dicendo che non può prendere l'indirizzo di una funzione
non statica; a questo punto se dichiaro la funzione 'ftopass' come
statica, tutto va a posto. Il problema è questo: cosa sto facendo
esattamente, visto che avro' usato il qualificatore 'static' al
massimo 3-4 volte in vita mia? La mia intenzione è che la funzione
lavori con i dati propri dell'istanza in cui è chiamata, ma non
vorrei che l'effetto fosse tutt'altro, tipo che il tutta la classe
viene resa 'static' e ho una sola istanza effettiva di 'dvar' o
qualcosa di simile. A occhio penserei che si tratti solo di una
specie di 'formalismo' richiesto dal compilatore (a proposito, uso
il Wacom) ma.... vorrei capire meglio la cosa.
    Nel caso, come si può mantenere il comportamento 'solito' di far
sì che ogni istanza della classe lavori con variabili univoche?
    Grazie a tutti,
    Corrado Bonuccelli
// ************************** inizio codice
// struttura di scambio dati
struct Sdexch   {  double  (*fptr)(double) ;  } ;
class Cext  // classe principale
{
        double     dvar ;
        double     ftopass (double) { return (dvar) ; }
        void        fwork ()
        {
                Sdexch    pars ;
                pars.fptr = &ftopass ;
        }
} ;

 ha scritto nel messaggio
news:fHrn6.39618$Y93.1...@news.infostrada.it...

Il problema è che l'assegnamento pars.fptr=&ftopass è illegale
Il compilatore ti segnala quel tipo di errore perchè se il metodo della
classe Cext fosse static allora l'assegnamento sarebbe legale, coincidendo i
tipi, solo che ciò che ottieni è diverso da ciò che volevi.
Prova a modificare il programma così:
//codice
class Cext;
struct Sdexch { double (Cext::* fptr) (double);}
......
di seguito come nel lstato riportato da te.
L.

 statica, tutto va a posto. 
La differenza fra un metodo "normale" ed un metodo "statico" sta nel fatto 
che il metodo normale ha tra i suoi parametri uno particolare: il parametro 
"this". Difatti un metodo puo' riferirsi ai membri di una istanza di una 
classe ( con l'uso esplicito del parametro this o con l'uso implicito, in 
tal caso e' il compilatore a usarlo ).
Per cui un metodo statico non ha la possibilita' di riferirsi ad alcuna 
istanza ( al limite a mebri statici ).
Tutto questo per dire che un puntatore a funzione e' diverso da un 
puntatore ad un metodo; Ti allego un esempio che ti permette di capire come 
dichiarare un puntatore ad un metodo e come usarlo; Ulteriori riferimenti
thinking c++ di Bruce Eckel, Volume I, Chapter11 : "Pointers to members" ( 
http://www.bruceckel.com
 )
ghigo@therra:/tmp$ cat prova.cpp
 
class   A {
  public:
          void effe( void ) { }
  static  void gi( void ) { }
} a;
 
void (*pi_gi)( void );
void (A::*pi_effe)( void );
 
int main( ){
        pi_effe = &A::effe;
 
        pi_gi = 
a.gi
;
        pi_gi = A::gi;
 
        pi_gi( );       // e' un membro statico : non ha senso
                        // riferirsi ad una istanza
 
        (a.*pi_effe)( );// e' un puntatore ad un metodo statico :
                        // si deve riferire ad una istanza
}
ghigo@therra:/tmp$ g++ -Wall -o prova prova.cpp
ghigo@therra:/tmp$

    Grazie delle risposte, veramente utili!
    Ciao, C.