Chodzi o to,ze w tym wzorcu wystepuje mechanizm dziedziczenia,oraz ilosc kodu drastycznie sie zwieksza poprzez deklarowanie klasy budowniczego oraz klasy kierownika.
W związku z tym pytam sie czy lepiej unikac tego wzorca i traktować go tak samo jak singleton (czyli jako antywzorzec) ?
Prosze tez o ocene implementacji wzorca budowniczego w C++.Nie jest kreatywna,wrecz mocno przerobiona z internetowego przykladu,ale nie ukryje ze jest to dla mnie koderski twardy orzech do zgryzienia na dzien dzisiejszy :P
#include <iostream>
class Computer
{
std::string processor;
std::string graphicCard;
std::string memoryRAM;
std::string hardDisc;
public:
inline void setProcessor(std::string comProcessor){processor=comProcessor;}
inline void setGraphicCard(std::string comGraphicCard){graphicCard=comGraphicCard;}
inline void setMemoryRAM(std::string comMemoryRAM){memoryRAM=comMemoryRAM;}
inline void setHardDisc(std::string comHardDisc){hardDisc=comHardDisc;}
inline std::string getProcessor()const{return processor;}
inline std::string getGraphicCard()const{return graphicCard;}
inline std::string getMemoryRAM()const{return memoryRAM;}
inline std::string getHardDisc()const{return hardDisc;}
};
///////////////////////////////////BUDOWNICZY/////////////////////////////////////////////////////////////
class Builder
{
protected:
Computer *computer;
public:
inline void newComputer(){computer = new Computer();}
Computer getComputer()const{return *computer;}
virtual void buildProcessor()=0;
virtual void buildGraphicCard()=0;
virtual void buildMemoryRAM()=0;
virtual void builHardDisc()=0;
};
class nerdComputer: public Builder
{
public:
nerdComputer(): Builder(){}
void buildProcessor(){computer->setProcessor("INTEL CELERON");}
void buildGraphicCard(){computer->setGraphicCard("NVIDIA RTX 2080 TI");}
void buildMemoryRAM(){computer->setMemoryRAM("DDR4 16GB");}
void builHardDisc(){computer->setHardDisc("WD PURPLE 2TB");}
};
////////////////////////////////KIEROWNIK/////////////////////////////////////////////////////////////////////
class Dircetor
{
Builder *builder;
public:
inline void setBuilder(Builder *b){builder=b;}
Computer getComputer(){return builder->getComputer();}
void make(){
builder->newComputer();
builder->buildProcessor();
builder->buildGraphicCard();
builder->buildMemoryRAM();
builder->builHardDisc();
}
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main()
{
Dircetor *chef = new Dircetor();
Builder *builder = new nerdComputer();
std::cout<<"PODZESPOLY KOMPUTEROWE\n";
std::cout<<"===================="<<'\n';
chef->setBuilder(builder);
chef->make();
Computer simpleComputer = chef->getComputer();
std::cout<<simpleComputer.getProcessor()<<'\n';
std::cout<<simpleComputer.getHardDisc()<<'\n';
std::cout<<simpleComputer.getGraphicCard()<<'\n';
std::cout<<simpleComputer.getMemoryRAM()<<'\n';
std::cout<<simpleComputer.getHardDisc()<<std::endl;
return 0;
}
I szybkie pytanie - czy uzywanie getterów i setterów (metody get i set) w deklaracji klasy to dobra praktyka ? To moj sposob na modyfikowanie cech obiektu bez naruszania zasad hermetyzacji : P