Ho una famiglia di classi, tutte derivate da una classe astratta.
In tutte le classi derivate c'e' un metodo set, che però necessita di parametri variabili in numero e tipo.
Con qualche riga di codice forse mi spiego meglio
codice:
class Astratta
{
public:
virtual void set(/*???*/)=0;
};
class Deriv1: public Astratta
{
public:
//qui set ha bisogno di due double
void set(const double& par1, const double& par2);
};
class Deriv2: public Astratta
{
public:
//qui set ha bisogno di tre double
void set(const double& par1, const double& par2, const double& par3);
};
class Deriv3: public Astratta
{
public:
//qui set ha bisogno di un vector di Tipo1
void set(const std::vector<Tipo1>& par);
};
La prima soluzione che mi e' venuta in mente e' la seguente: in Astratta implemento piu' metodi set, tutti che lanciano eccezione, mentre nelle classi derivate implemento solo il metodo corretto
codice:
class Astratta
//la classe rimane astratta per altri metodi che qui non sono riportati
{
public:
//i metodi set lanciano eccezione
virtual void set(const double& par1, const double& par2){/*lancio eccezione*/};
virtual void set(const double& par1, const double& par2, const double& par3){/*lancio eccezione*/};
virtual void set(const std::vector<Tipo1>& par){/*lancio eccezione*/};
//nel caso una nuova classe Derivn abbia dei parametri diversi, sara' necessario aggiungere un ulteriore metodo set
};
class Deriv1: public Astratta
{
public:
//qui set ha bisogno di due double
void set(const double& par1, const double& par2) override{/*...*/};
};
class Deriv2: public Astratta
{
public:
//qui set ha bisogno di tre double
void set(const double& par1, const double& par2, const double& par3) override{/*...*/};
};
class Deriv3: public Astratta
{
public:
//qui set ha bisogno di un vector di Tipo1
void set(const std::vector<Tipo1>& par) override{/*...*/};
};
La seconda soluzione e' la seguente: dato che i parametri del metodo set sono un 'qualcosa di omogeneo' dal punto di vista del loro significato,
potrei creare una ulteriore famiglia di classi, la cui classe astratta da cui derivo le successive diventerebbe quello che vado a passare al metodo set.
Diciamo che diventerebbe:
codice:
class NuovaAstratta
{
};
class Nuova1: public NuovaAstratta
{
};
mentre la prima famiglia di classi potrebbe diventare
codice:
class Astratta
{
public:
virtual void set(const NuovaAstratta*& puntatore)=0;
};
class Deriv1: public Astratta
{
public:
//qui set ha bisogno di due double
void set(const NuovaAstratta*& puntatore) override;
};
class Deriv2: public Astratta
{
public:
//qui set ha bisogno di tre double
void set(const NuovaAstratta*& puntatore) override;
};
class Deriv3: public Astratta
{
public:
//qui set ha bisogno di un vector di Tipo1
void set(const NuovaAstratta*& puntatore) override;
};
In modo analogo potrebbe funzionare quindi per il metodo get, che restituirebbe anch'esso sempre lo stesso tipo, NuovaAstratta.
Ma qui mi blocco nuovamente, perche' mi sembra che abbia semplicemente spostato il problema: avro' anche qui set e get che hanno lo stesso problema di parametri passati o restituiti diversi...
C'e' qualche via d'uscita, senza dover implementare infiniti metodi set e get?
In realta' pensavo alla possibilita' di usare 'i tre puntini' (stdarg), ma da quello che ho capito e sperimentato, tra i parametri opzionali non digerisce i vector...e sistemerei solamente il metodo set.
Nella speranza che Shodan legga, tra i Design Pattern mi sembrava potesse darmi una mano Bridge, ma non mi sblocco...
Grazie a tutti.