Attualmente sto rifattorizzando una classe che sembra (dopo alcuni refactoring e molto semplificata) in qualche modo simile a questa:
class Foo
{
public:
Foo(bool someFlag) : m_flag(someFlag) { };
void doThings();
void doOtherThings()
{
doPrivateThings();
if (m_flag)
doFlagThings();
else
doNoFlagThings();
}
private:
void doPrivateThings();
void doFlagThings();
void doNoFlagThings();
bool m_flag;
}
Note:
* m_flag essendo lì è il risultato del refactoring (che di gran lunga non viene eseguito) - inizialmente ogni funzione individualmente ramificata ( if (check_something()) ) su qualcosa per cui il risultato era già determinato / fisso durante la costruzione dell'oggetto. < br>
* Le funzioni doFlagThings() e doNoFlagThings() sono piuttosto piccole (~ 3-5 linee di codice) e ci sono al massimo 3-4 funzioni che si discostano a seconda di m_flag .
Quindi, il passo successivo è sbarazzarsi di someFlag - l'unica domanda è come.
Un modo sarebbe utilizzare un genitore astratto e l'ereditarietà:
class FooBase
{
public:
FooBase();
void doThings();
void doOtherThings()
{
doPrivateThings();
doSpecializedThings();
}
private:
void doPrivateThings();
virtual void doSpecializedThings() = 0;
}
class FlagFoo : public FooBase
{
public:
FlagFoo();
private:
void doSpecializedThings() override { ... };
}
class NoFlagFoo : public FooBase
{
public:
NoFlagFoo();
private:
void doSpecializedThings() override { ... };
}
L'altro modo sarebbe utilizzare il modello e la composizione della strategia, cioè
class Foo
{
public:
Foo(IDoThingsStrategystrategy strategy) : m_Strategy(strategy) { };
void doThings();
void doOtherThings()
{
doPrivateThings();
m_Strategy.doSpecializedThings();
}
private:
void doPrivateThings();
IDoThingsStrategym_Strategy;
}
class IDoThingsStrategy
{
public:
IDoThingsStrategy();
virtual void doSpecializedThings() = 0;
}
class DoThingsFlagStrategy : public IDoThingsStrategy
{
public:
DoThingsFlagStrategy();
void doSpecializedThings() override;
}
class DoThingsNoFlagStrategy : public IDoThingsStrategy
{
public:
DoThingsNoFlagStrategy();
void doSpecializedThings() override;
}
Ma sembra molto eccessivo e presenta il problema che il creatore di Foo deve ora conoscere le diverse Strategie per crearle e alimentarle a Foo .
Quindi la domanda è: dovrei andare con l'ereditarietà (anche se uno dovrebbe preferire la composizione sull'ereditarietà) o il modello della strategia o c'è un modo migliore che non vedo proprio adesso?