Newsgroup: it.comp.lang.c++
Titolo: domanda azzardatissima parte seconda (lungo)

ho scritto questo template seguendo l'esempio fornitomi da EMG qualche
giorno fa
template <class Type, typename T>
class Confronto {
public:
 Confronto( T n): number(n) {}
 bool operator () ( const Type &Type_Class ) {
  // get_n() è una funzione presente in ogni classe
  // in cui serva tale confronto
  return Type_Class.get_n() == n;
 }
private:
 T number;
};
adesso, se ho una funzione get_n() in ogni classe in cui si abbia la
necessità di effettuare un confronto con l'operatore precedentemente
descritto, questa get_n() potrebbe limitarsi a richiamare la funzione membro
di tale classe del tipo "type get_type()" (ke per necessità ha un nome
diverso a seconda della classe di cui fa parte, per cui "type" potrebbe
essere un int, uno short, un unsigned o un long).
Il problema principale è sapere se effettivamente una tale idea va bene (e
questo posso verificarlo da solo facendo un programma di prova), ma posto
che tale metodo funzioni, ho un problema ben più grande che dipende da
secondo me da un difetto "organizzativo" delle classi e delle loro funzioni
membro.
Data la seguente classe
class A {
public:
    int get_n() {
        return( get_intA() );
    };
private:
    int ia;
    short sb;
    int get_intA() { return(ia) };
    short get_shortA() { return(sb) };
};
data ora la lista
list<A> listaA;
se voglio scorrere la lista cercando un elemento seguendo ancora l'esempio
fornitomi da EMG, dovrei scrivere una cosa simile (ho volutamente
tralasciato la parte riguardante la definizione di un oggetto Confronto):
std::list < A >::iterator i = listaA.begin();
 int prova = 5;
 i = find_if(listaA.begin(), listaA.end(), Confronto( prova ));
ma se ho la necessità di confrontare anche il valore del membro privato sb,
(sempre che sia possibile) come devo modificare il template per utilizzare
lo stesso schema di ricerca?
Scusate la domanda poco opportuna al contenuto di questo NG
--
Bruno

 Scusate la domanda poco opportuna al contenuto di questo NG
Perché? A me sembra in tema.
EMG

 EMG
Bruno

 all'occorrenza un'altra funzione (es. get_shortA() ) al posto di get_intA().
Non ho capito bene. Forse potresti definire piů funzioni di confronto?
EMG


Sicuramente, ma a quel punto tanto vale creare diverse classi che abbiano
all'interno ognuna  un membro che effettui il confronto richiamando la
funzione adatta.
Se invece potessi unificare tutte queste funzioni in una sola avrei la
semplicità fatta codice :)
E' proprio questo che mi chiedo: se per effettuare tale confronto sfruttando
funzioni che differiscono solo per valore di ritorno sia possibile
utilizzare una sola unica funzione che sappia scegliere la funzione più
adatta al singolo caso.... meglio di così non so spiegarmi, mi dispiace
tanto se ho queste idee malate :(
Bruno

 adatta al singolo caso....
Forse intendevi dire "utilizzare un solo unico template che sappia
scegliere...", giusto? Mi dispiace ma non ho idee chiare al riguardo.
EMG

In realta' la tua domanda e' perfettamente in tema. Dovresti poter
parametrizzare anche il metodo che chiami, perche' i puntatori a
funzioni membro sono validi come parametri di template. Non sono pero'
sicuro che siano supportati da tutti i compilatori.
Ciao,
Nicola

 ha scritto nel messaggio
news:3B39D376...@divalsim.it...



class Confronto {
    public:
        Confronto( T n): number(n) {}
        bool operator () ( const Type &Type_Class ) const {
		// Qui uso il puntatore a membro funzione
		// che ho passato
        	return (Type_Class.*Member)() == number;
        }
    private:
    	T number;
};
class A {
public:
	A(int i, short s) : ia(i), sb(s) {}
    int get_n() const { return get_intA(); }
    int get_intA() const { return ia; }
    short get_shortA() const { return sb; }
private:
    int ia;
    short sb;
};
int main(int argc, char* argv[]) {
    std::list<A> la;
    la.push_back(A(1,5));
    la.push_back(A(7,2));
    std::list < A >::iterator i = la.begin();
    int prova = 1;
    i = std::find_if(la.begin(), la.end(), 
	// Qui sfrutto il default: il confronto viene fatto
	// con get_n
	Confronto<A,int>( prova ));
    std::cout << i->get_intA() << " " << i->get_shortA() << '\n';
    short s = 2;
    i = find_if(la.begin(), la.end(), 
	// Qui specifico quale funzione membro voglio usare
	Confronto<A,short,&A::get_shortA>( s ));
    std::cout << i->get_intA() << " " << i->get_shortA() << '\n';
    std::cin.get();
    return 0;
}