Newsgroup: it.comp.lang.c++
Titolo: metodo unico con piu' algoritmi realizzativi

Salve.
Devo realizzare un metodo che opera sui dati di una classe.
Esistono algoritmi diversi per tale operazione e vorrei realizzarli tutti
 con metodi privati della classe...)
riservandomi la possibilita' di "collegare" il metodo pubblico(che ha sempre
lo stesso nome!) con la
funzione che realizza l'algoritmo particolare.
C'e' un modo "standard" di fare questo?
Grazie.

Ciao
Provo a darti una mano.
Ti serve di "collegare" il metodo in modo statico (conosciuto a 
compile-time) o dinamico?
Non so se uò esserti utile ma ti mando questo pezzo di codice, che, per 
inciso, funziona su GCC 2.95.3.
Ci sono 3 modi descritti, li puoi ovviamente adattare al caso.
Tutti e 3 usano in modo diverso le "Policy" (Alexandrescu "Modern C++ 
Design, 
www.moderncppdesign.com
)
La prima, MyClass, è un modo statico per scegliere una policy alla 
dichiarazione della variabile. C'è una relazione "use" tra MyClass e la 
policy.
La seconda, MyClassDerived, è un altro modo statico: MyClassDerived 
deriva la policy che scegli nelle dichiarazioni.
La terza, MyDynamicClass, è un modo dinamico di legare il metodo alla 
policy: MyDynamicClass deriva da *tutte* le policy (puoi derivarle anche 
privatamente) e quando ne vuoi scegliere una applichi un dynamic_cast a 
this, perché un oggetto MyDynamicClass *E'* un oggetto di qualsiasi 
classe base da cui MyDerivedClass deriva.
Puoi approfondire questi argomenti cercando in rete "Generic 
Programming", o acquistando il citato libro del buon Alexandrescu.
spero di esserti stato di aiuto :)
benedetto
// ------------------------------------------------------
// ------------------------------------------------------
// ------------------------------------------------------
#include <iostream>
template <class T>
struct fast_sort
{
   static void sort (T*)
   {
     cout << " fast_sort::sort" << endl;
   }
};
template <class T>
struct slow_sort
{
   static void sort (T*)
   {
     cout << " slow_sort::sort" << endl;
   }
};
template <template <class> class SortPolicy = slow_sort>
class MyClass
{
   // my data
   int my_data[10000];
public:
   MyClass () {}
   // my methods
   // ...
   //
   void some_method ()
   {
     // ... qui uso l'algoritmo
     SortPolicy<int>::sort (my_data);
     // ..
   }
};
template <template <class> class SortPolicy = slow_sort>
class MyClassDerived : public SortPolicy<int>
{
};
MyClass<fast_sort> fast;
MyClass<slow_sort> slow;
MyClass<> other;
MyClassDerived<fast_sort> fast_derived;
template <class T>
class fast_sort2
{
public:
   void sort (T*) {
     cout << "fast_sort2::sort" << endl;
   }
};
template <class T>
class slow_sort2
{
public:
   void sort (T*) {
     cout << "slow_sort2::sort" << endl;
   }
};
template <class T>
class MyDynamicClass : public fast_sort2<T>, public slow_sort2<T>
{
   T *my_data;
public:
   MyDynamicClass () {
     my_data = new T [100];
   }
   void do_something (int param)
   {
     if (param == 0)
       {
	(dynamic_cast<fast_sort2<T>*>(this))->sort(my_data);
       } else       {
	(dynamic_cast<slow_sort2<T>*>(this))->sort(my_data);
       }
   }
};
MyDynamicClass<int> dynamic;
int main ()
{
   fast.some_method();
   slow.some_method();
   other.some_method();
   int array[] = { 2,5,3,45,6,53,3,55,};
   fast_derived.sort (array);
   dynamic.do_something (0);
   dynamic.do_something (2);
   return 0;
}
// ------------------------------------------------------
// ------------------------------------------------------
// ------------------------------------------------------
