[디자인 패턴] 생성 패턴 - 1. 팩터리 Factory
** 팩토리 패턴이란? **
🌟 정의
객체를 생성할 때 그 객체의 생성자를 직접 호출하지 않고, 객체 생성을 담담하는 팩토리에 요청하는 구조를 뜻한다.
🌟 장점
1. 객체를 생성하는 코드가 프로그램의 이곳저곳에 산만하게 흩어지지 않고 객체를 생성하는 기능을 한 곳에 모아둘 수 있다.
2. 클래스 타입을 정확히 몰라도 클래스 계층에 맞게 객체를 생성할 수 있다.
3. 팩토리는 클래스 계층에 따라 실행할 수 있다.
4. 객체를 정확한 순서로 생성하려면 복잡한 단계가 필요하거나, 생성된 객체를 항상 다른 객체와 일정한 방식으로 연결해야 할 때 팩토리를 사용하면 편하다.
** 팩토리 종류 **
🌟 정적 팩터리 메서드 (static factory method)
객체를 생성해서 리턴하는 함수.
class Point
{
// use a factory method
Point(float x, float y) : x(x), y(y){}
public:
float x, y;
friend class PointFactory;
};
class PointFactory
{
static Point NewCartesian(float x, float y)
{
return Point{ x,y };
}
static Point NewPolar(float r, float theta)
{
return Point{ r*cos(theta), r*sin(theta) };
}
};
🔸 여기서 잠깐 !! 🔸
* 팩토리 함수에 static을 사용하는 이유는 뭘까 ?
객체를 생성하지 않고 static 메서드에 접근이 가능하기 때문이다. static을 사용하면 클래스가 메모리에 올라갈때 이미 자동적으로 생성되기 때문에 인스턴스들이 공통적으로 값을 유지해야할 때 사용한다. 인스턴스가 필요없기 때문에 메서드 호출이 짧아지기 때문에 효율이 올라가는 장점이 있다.
* 메서드란?
어떤 클래스의 멤버함수를 의미한다.
🌟 팩터리
객체를 생성하는 함수들을 별도의 클래스에 몰아넣은 클래스를 팩터리라고 한다.
🌟 내부 팩터리
생성할 타입의 내부 클래스로서 존재하는 간단한 팩터리를 말한다. friend 키워드에 해당하는 문법이 없는 프로그래밍 언어들에서는 내부 팩터리를 흔하게 사용하며, 팩터리가 생성해야 할 클래스가 단 한 종일 때 유용하다.
생성할 타입의 내부 클래스이기 때문에 private멤버들에 자동적으로 자유로운 접근 권한을 가진다는 점이 있다. 내부 클래스를 보유한 외부 클래스도 내부 클래스의 private 멤버들에 접근할 수 있다.
🌟 추상 팩터리
여러 종류의 연관 객체들을 생성해야 할 경우사용한다.
class CarFactory
{
public:
virtual ~CarFactory() = default; //항상 가상 소멸자로 정의한다.
std::unique_ptr<Car> requestCar();
size_t getNumberOfCarsProduced() const;
protected:
virtual std::unique_ptr<Car> createCar() = 0;
private:
size_t mNumberOfCarsProduced = 0;
};
class FordFactory : public CarFactory
{
protected:
virtual std::unique_ptr<Car> createCar() override;
};
class ToyotaFactory : public CarFactory
{
protected:
virtual std::unique_ptr<Car> createCar() override;
};
//---------------------------------------------------------------------//
std::unique_ptr<Car> CarFactory::requestCar()
{
++mNumberOfCarsProduced;
return createCar();
}
size_t CarFactory::getNumberOfCarsProduced() const
{
return mNumberOfCarsProduced;
}
std::unique_ptr<Car> FordFactory::createCar()
{
return std::make_unique<Ford>();
}
std::unique_ptr<Car> ToyotaFactory::createCar()
{
return std::make_unique<Toyota>();
}
//---------------------------------------------------------------------//
class LeastBusyFactory : public CarFactory
{
public:
explicit LeastBusyFactory(vector<unique_ptr<CarFactory>>&& factories);
// explicit 자신이 설정한 방식으로만 객체를 만드려고 할때.
// 여러 공장을 갖는 LeastBusyFactory 인스턴스를 생성한다.
protected:
virtual unique_ptr<Car> createCar() override;
private:
vector<unique_ptr<CarFactory>> mFactories;
};
LeastBusyFactory::LeastBusyFactory(vector<unique_ptr<CarFactory>>&& factories)
: mFactories(std::move(factories))
{
if (mFactories.empty())
throw runtime_error("No factories provided.");
}
unique_ptr<Car> LeastBusyFactory::createCar()
{
CarFactory* bestSoFar = mFactories[0].get();
for (auto& factory : mFactories) {
if (factory->getNumberOfCarsProduced() <
bestSoFar->getNumberOfCarsProduced()) {
bestSoFar = factory.get();
}
}
return bestSoFar->requestCar();
}🌟 함수형 팩터리
클래스 대신 함수의 형태로 존재하는 팩터리
class DrinkWithVolumeFactory
{
map<string, function<unique_ptr<HotDrink>()>> factories;
public:
DrinkWithVolumeFactory()
{
factories["tea"] = [] {
auto tea = make_unique<Tea>();
tea->prepare(200);
return tea;
};
factories["Coffee"] = [] {
auto coffee = make_unique<Coffee>();
coffee->prepare(10);
return Coffee;
};
}
unique_ptr<HotDrink> make_drink(const string& name);
};
inline unique_ptr<HotDrink> DrinkWithVolumeFactory::make_drink(const string& name)
{
return factories[name]();
}
** 출처 **
1. 모던 c++ 디자인 패턴 / 드미트리 네스터룩 지음 / 출판사 : 깃벗
2. 전문가를 위한 c++ (개정 4판) : C++17 / 마크 그레고리 지음 / 출판사 : 한빛 미디어