[강의] 12월 31일 수업정리

오늘은 (추상) 팩토리 패턴에 대한 수업을 들었다.

 

1. 팩토리 패턴 

1.1 정의 :

• 객체를 생성하기 위한 인터페이스를 정의하는데, 어떤 클래스의 인스턴스를 만들지는 서브클래스에서 결정하게 만든다. 
• 즉 팩토리 메소드 패턴을 이용하 클래스의 인스턴스를 만드는 일을 서브클래스에게 맡기는 것.

1.2 UML

Product - 생성될 객체의 인터페이스

ConcreteProduct - Product 인터페이스를 구현한 구상 클래스

Creator - 객체를 생성하는 팩토리 메소드를 가진 인터페이스

ConcreteCreator - Creator 인터페이스를 구현한 구상 클래스

 

1.3 구현

product .h / cpp

#pragma once

#include <stdio.h>

__interface I_PRODUCT
{
	void operation();
};


class C_PRODUCT abstract : public I_PRODUCT
{
public:
	C_PRODUCT() = default;
	virtual ~C_PRODUCT() = default;
};


class C_PRODUCT_A : public C_PRODUCT
{
public:
	void operation() override;
};

class C_PRODUCT_B : public C_PRODUCT
{
public:
	void operation() override;
};


#include "product.h"

void C_PRODUCT_A::operation()
{
	printf("product A\n");
}

void C_PRODUCT_B::operation()
{
	printf("product B\n");
}

 

creator .h / cpp

#pragma once

#include "product.h"

__interface I_CREATOR
{
	void initfactoryMethod();
	void relese();
};

class C_CREATOR abstract : public I_CREATOR
{
protected:
	C_PRODUCT* m_pProduct;
public:
	C_CREATOR() = default;
	virtual ~C_CREATOR() = default;
	void use();

	void relese() final;
};

class C_CREATOR_A : public C_CREATOR
{
public:
	void initfactoryMethod() override;
};

class C_CREATOR_B : public C_CREATOR
{
public:
	void initfactoryMethod() override;
};



#include "creator.h"

void C_CREATOR_A::initfactoryMethod()
{
	m_pProduct = new C_PRODUCT_A{};
}

void C_CREATOR_B::initfactoryMethod()
{
	m_pProduct = new C_PRODUCT_B{};
}

void C_CREATOR::use()
{
	//C_PRODUCT* pProduct = factoryMethod();

	//printf("사용 : ");
	//pProduct->operation();

	//delete pProduct;

	printf("사용 : ");
	m_pProduct->operation();
}

void C_CREATOR::relese()
{
	delete m_pProduct;
}

 

main.cpp

#include <iostream>
#include "creator.h"

int main()
{
	C_CREATOR* pCreator = new C_CREATOR_A{};

	pCreator->initfactoryMethod();

	pCreator->use();
	pCreator->use();
	pCreator->use();
	pCreator->use();
	pCreator->use();

	pCreator->relese();
	delete pCreator;
}

 

2. 추상 팩토리 패턴

2.1 정의 :

• 인터페이스를 이용하여 서로 연관된, 또는 의존하는 객체를 구상 클래스를 지정하지 않고도 생성.
• 즉, 서로 관련이 있는 객체들을 통째로 묶어서 팩토리 클래스로 만들고, 이들 팩토리를 조건에 따라 생성하도록 다시 팩토리를 만들어서 객체를 생성하는 패턴

2.2 UML

AbstractFactoty - 각각의 Product 객체를 생산하는 메소드를 지닌 추상 팩토리 인터페이스

ConcreteFactory - AbstractFactory 인터페이스를 구현한 구상 팩토리 클래스

Client - 팩토리에게 객체의 생성을 요청하는 클래스

AbstractProductA,B - 팩토리에 의해 생성되는 클래스들에 대한 인터페이스

ProductA_1,A_2,B_1,B_2 - 실제 생성될 Product 구상 클래스

2.3 구현

 

factory.h

#pragma once
#include "food.h"

class C_FACTORY abstract
{
public:
	enum class E_TYPE
	{
		E_NODDLE,
		E_FRIED,

		E_MAXTYPE
	};
private:
	C_FOOD* (C_FACTORY::*m_arCreate[(int)E_TYPE::E_MAXTYPE])();

private:
	virtual C_FOOD* createNoddle() abstract;
	virtual C_FOOD* createFired() abstract;


public:
	C_FACTORY() = default;
	virtual ~C_FACTORY() = default;
	void init();
	C_FOOD* createFood(E_TYPE eType);
};


class C_KOREANFOOD : public C_FACTORY
{
private:
	C_FOOD* createNoddle() override;
	C_FOOD* createFired() override;
};

class C_JAPANESEFOOD : public C_FACTORY
{
private:
	C_FOOD* createNoddle() override;
	C_FOOD* createFired() override;
};

 

food.h / cpp

#pragma once
#include <stdio.h>

class C_FOOD abstract
{
public:
	C_FOOD() = default;
	virtual ~C_FOOD() = default;
	virtual void print() abstract;
};


class C_RAMEN : public C_FOOD
{
public:
	virtual void print() override
	{printf("라멘\n");}
};

class C_NOODLE : public C_FOOD
{
public:
	virtual void print() override
	{printf("국수\n");}
};

class C_PAJEON : public C_FOOD
{
public:
	virtual void print() override
	{printf("파전\n");}
};

class C_TONKATSU : public C_FOOD
{
public:
	virtual void print() override
	{printf("돈까스\n");}
};



#include "factory.h"

void C_FACTORY::init()
{
	m_arCreate[(int)E_TYPE::E_NODDLE] = &C_FACTORY::createNoddle;
	m_arCreate[(int)E_TYPE::E_FRIED] = &C_FACTORY::createFired;
}

C_FOOD* C_FACTORY::createFood(E_TYPE eType)
{
	return (this->*m_arCreate[(int)eType])();;
}

C_FOOD* C_KOREANFOOD::createNoddle()
{
	return new C_NOODLE{};
}

C_FOOD* C_KOREANFOOD::createFired()
{
	return new C_PAJEON;
}

C_FOOD* C_JAPANESEFOOD::createNoddle()
{
	return new C_RAMEN;
}

C_FOOD* C_JAPANESEFOOD::createFired()
{
	return new C_TONKATSU;
}

 

main.cpp

#include <iostream>
#include "factory.h"

int main()
{
	C_FOOD* pFood{};
	C_FACTORY* pFactory = new C_JAPANESEFOOD{};
	pFactory->init();

	pFood = pFactory->createFood(C_FACTORY::E_TYPE::E_NODDLE);
	pFood->print();
}