Newsgroup: it.comp.lang.c++
Titolo: puntatori a funzione e template

sto definendo una classe che implementa la bwt e la usa come interleaver.
Riporto un po' di codice:
template < class DataType > class BWT:public Interleaver < DataType >
  {
   .....
    static int bwt_compar (const void *a, const void *b)
    {
            Data < DataType > *data_a = (Data < DataType > *) a;
            Data < DataType > *data_b = (Data < DataType > *) b;
            std::cout << data_a << std::endl;
            std::cout << data_b << std::endl;
            std::cout << data_a->size() << std::endl;
            std::cout << data_b->size() << std::endl;
            for (int i = 0 ; i < data_a->size() ; i++) {
                        if ((*data_a)[i] < (*data_b)[i]) return 1;
                        else if ((*data_a)[i] > (*data_b)[i]) return -1;
            }
            return 0;
    }
    void bwt (Data < DataType > *data)
    {
      Data < DataType > * tmp = new Data < DataType >(data);
      for (int i=0 ; i < data->size() ; i++) {
              _list[i] = tmp;
              tmp = tmp->right_rotate ();
              std::cout << &_list[i] << std::endl;
      }
      std::cout << std::endl;
      for (int i=0 ; i < tmp->size() ; i++)
	{
	  std::cout <<  _list[i]->size() << "  " ;
	  _list[i]->dump();
	}
      std::cout << std::endl;
      qsort ((void*) _list, tmp->size() , sizeof (Data < DataType > *),
bwt_compar);
      std::cout << std::endl;
      for (int i=0 ; i < tmp->size() ; i++)
	{
	  std::cout <<  _list[i]->size() << "  " ;
	  _list[i]->dump();
	}
      std::cout << std::endl;
      for (int i=0 ; i < data->size() ; i++) {
        (*data)[i] = (*(_list[i]))[_list[i]->size() -1];
      }
Il problema e' che se non metto static in bwt_compar non mi torva il
puntatore a funzone usato in qsort. Pero' se metto static mi viene fuori
che la qsort ha dei problemi ad accedere ai campi degli oggetti Data.
Puo' essere che poiche' e' una funzione statica non si adatta
all'istanza del template?
Se si' cosa posso fare?
Inviato da X-Privat.Org - Registrazione gratuita 
http://www.x-privat.org/join.php

 Se si' cosa posso fare?
Questo è un problema piuttosto ricorrente. I template non c'entrano 
niente (del resto è facile verificarlo).
1) Ogni funzione membro /non static/ di una classe riceve un parametro 
implicito "this", puntatore a una istanza della stessa classe.
2) Ogni funzione membro /static/ *non* riceve alcun parametro implicito 
aggiuntivo quindi non può accedere a dati relativi a una determinata 
istanza, ma soltanto a dati statici, cioè anch'essi comuni a tutte le 
istanze della stessa classe.
Leggi il thread "Puntatori a funzioni ed errore di compilazione" di 
massi del 17/03/2006.
Kiuhnm

 massi del 17/03/2006.
ok, allora non la metto statica.
ho letto il thread ma ancora non funziona.
Il problema e' che la funzione di sort e' definita nella classe, quindi
lui vede un qualcosa che e' del tipo
int (Turbo::BWT<char>::)(const void*, const void*)
ma la funzione qsort vuole invece
int (*)(const void*, const void*)
quindi se ho capito bene il problema sta nel fatto che la funzione e'
dnetro alla classe e non fuori. Io non vorrei tirarla fuori. Ma allora
come posso fare? perche' se ho capito bene la funzione qsort definita in
<cstdlib> non funziona con nessuna classe......


 ok, allora non la metto statica.
Al posto di static metti "friend".
Kiuhnm

 ok, allora non la metto statica.
1) se vuoi un metodo a livello di istanza NON devi dichiararlo statico, 
se vuoi un metodo a livello di classe DEVI dichiararlo statico.
2) un metodo a livello di istanza può accedere implicitamente sia a 
membri a livello di classe che a livello di istanza, un metodo a livello 
di classe può accedere implicitamente solo a membri a livello di classe.
3) un metodo a livello di classe è una funzione, un metodo a livello di 
istanza NON è una funzione: è un membro.
4) qsort vuole come parametro una funzione, non puoi passare a qsort 
come parametro un metodo.
Conseguenza: qualunque cosa passi a qsort non potrà accedere 
implicitamente a membri di una istanza (di nessuna classe).
Naturalmente può accedere a oggetti globali e/o che gli vengono passati 
come parametro (ovviamente previa riconversione dei void*) e, se la 
funzione è metodo a livello di classe e gli oggetti sono della stessa 
classe, può accedere ai loro membri in via esplicita (ma mai implicita).

 implicitamente a membri di una istanza (di nessuna classe).
Morale: usa std::sort al posto di qsort.
Ciao,
Nicola


non ha funzionato.
sinceramente mi sono un po' rotto, mi sono fatto il sort a mano e ci ho
messo un attimo.
eventualmente fissero' il tutto in futuro.
