ciao.
Ho implementato una funzione template che serializza un vector, piu o meno cosi:
codice:
template < class T, class Allocator>
void Save(T& vect)
{
	int count = vect.size();
	T::iterator itBegin = vect.begin(),
		itEnd = vect.end();
	ecc.... serializzazione
}

std::vector<double> v;
Save<std::vector<double>, std::allocator<double> >(v);
Ho un metodo save in ogni classe da serializzare e uso le stessse funzioni generiche per il salvataggio.
Ho un interfaccia in cui ho dei metodi generici per la serializzazione.
questa interfaccia è implementata da due classi , una CSizer che mi calcola la grandezza delle classi da serializzare e una che fa la serializzazione vera e propria CSerialize.
la Csizer implementera l'interfaccia ed eseguira un calcolo di size, mentre la CSerialize fara la serializzazione.
Chiaramente uso gli stessi metodi generici nella funzione Save e uso prima il CSizer(arrivano come parametri della funzione save) e poi il CSerialize in due passi: uno mi calcola il size del buffer da allocare e una serializza sul buffer.

Il problema è che non so come posso fare con la classe template di sopra. perchè il template bene o male lo devo usare e non riesco a fare una funzione template virtual(forse sbaglio) ma voi come fareste?
forse implementare due funzioni non virtual?

per la verità ho letto qualcosa sul type erasure se potesse servire tipo:
codice:
class placeholder
{
public:
  virtual ~placeholder() {}
  virtual placeholder* clone() const=0;
};

And this is the wrapper class template:

template<typename ValueType>
class holder : public placeholder
{
public:
  holder(ValueType const & value) : held(value) {}
  virtual placeholder* clone() const 
  {return new holder(held);}

private:
  ValueType held;
};
puo essere una strada?
o forse usare gli iterator?
grazie.