[2026] C++ Factory Pattern 완벽 가이드 | 객체 생성 캡슐화와 확장성
![[2026] C++ Factory Pattern 완벽 가이드 | 객체 생성 캡슐화와 확장성](/og/s/cpp-factory-pattern.webp)
이 글의 핵심
C++ Factory Pattern : 객체 생성 캡슐화와 확장성. Factory Pattern이란?. 왜 필요한가·Simple Factory.
Factory Pattern이란? 왜 필요한가
문제 시나리오: 객체 생성 로직의 중복과 의존성
문제: 클라이언트 코드가 구체 클래스에 직접 의존하면, 새 타입 추가 시 모든 클라이언트 코드를 수정해야 합니다. 아래 코드는 cpp를 사용한 구현 예제입니다. 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
// 클라이언트 코드 (나쁜 예)
std::unique_ptr<Logger> logger;
if (config == "console") {
logger = std::make_unique<ConsoleLogger>();
} else if (config == "file") {
logger = std::make_unique<FileLogger>();
} else if (config == "network") {
logger = std::make_unique<NetworkLogger>();
}
// 새 타입 추가 시 모든 클라이언트 수정 필요해결: Factory Pattern은 객체 생성 로직을 캡슐화해, 클라이언트는 인터페이스만 의존하고, Factory가 구체 클래스를 결정합니다. 다음은 cpp를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
// Factory
// 타입 정의
class LoggerFactory {
public:
static std::unique_ptr<Logger> create(const std::string& type) {
if (type == "console") return std::make_unique<ConsoleLogger>();
if (type == "file") return std::make_unique<FileLogger>();
if (type == "network") return std::make_unique<NetworkLogger>();
return nullptr;
}
};
// 클라이언트 코드 (좋은 예)
auto logger = LoggerFactory::create(config);
logger->log("Hello");
// 새 타입 추가 시 Factory만 수정아래 코드는 mermaid를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
flowchart TD
client[Client]
factory["LoggerFactory create(type)"]
console[ConsoleLogger]
file[FileLogger]
network[NetworkLogger]
client --> factory
factory --> console
factory --> file
factory --> network
목차
- Simple Factory
- Factory Method
- Abstract Factory
- 자동 등록 Factory
- 자주 발생하는 문제와 해결법
- 프로덕션 패턴
- 완전한 예제: 플러그인 시스템
1. Simple Factory
기본 구조
다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
#include <memory>
#include <string>
#include <iostream>
class Shape {
public:
virtual void draw() const = 0;
virtual ~Shape() = default;
};
class Circle : public Shape {
public:
void draw() const override {
std::cout << "Drawing Circle\n";
}
};
class Rectangle : public Shape {
public:
void draw() const override {
std::cout << "Drawing Rectangle\n";
}
};
class ShapeFactory {
public:
static std::unique_ptr<Shape> create(const std::string& type) {
if (type == "circle") {
return std::make_unique<Circle>();
} else if (type == "rectangle") {
return std::make_unique<Rectangle>();
}
return nullptr;
}
};
int main() {
auto shape = ShapeFactory::create("circle");
if (shape) {
shape->draw(); // "Drawing Circle"
}
}2. Factory Method
팩토리를 상속으로 확장
다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
#include <memory>
#include <iostream>
class Document {
public:
virtual void open() = 0;
virtual ~Document() = default;
};
class PDFDocument : public Document {
public:
void open() override {
std::cout << "Opening PDF\n";
}
};
class WordDocument : public Document {
public:
void open() override {
std::cout << "Opening Word\n";
}
};
// Creator (Factory Method 패턴)
class Application {
public:
virtual std::unique_ptr<Document> createDocument() = 0;
void newDocument() {
auto doc = createDocument();
doc->open();
}
virtual ~Application() = default;
};
class PDFApplication : public Application {
public:
std::unique_ptr<Document> createDocument() override {
return std::make_unique<PDFDocument>();
}
};
class WordApplication : public Application {
public:
std::unique_ptr<Document> createDocument() override {
return std::make_unique<WordDocument>();
}
};
int main() {
std::unique_ptr<Application> app = std::make_unique<PDFApplication>();
app->newDocument(); // "Opening PDF"
}3. Abstract Factory
관련 객체 군 생성
다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
#include <memory>
#include <iostream>
// 제품군
class Button {
public:
virtual void render() = 0;
virtual ~Button() = default;
};
class Checkbox {
public:
virtual void render() = 0;
virtual ~Checkbox() = default;
};
// Windows 제품
class WindowsButton : public Button {
public:
void render() override {
std::cout << "Rendering Windows Button\n";
}
};
class WindowsCheckbox : public Checkbox {
public:
void render() override {
std::cout << "Rendering Windows Checkbox\n";
}
};
// Mac 제품
class MacButton : public Button {
public:
void render() override {
std::cout << "Rendering Mac Button\n";
}
};
class MacCheckbox : public Checkbox {
public:
void render() override {
std::cout << "Rendering Mac Checkbox\n";
}
};
// Abstract Factory
class GUIFactory {
public:
virtual std::unique_ptr<Button> createButton() = 0;
virtual std::unique_ptr<Checkbox> createCheckbox() = 0;
virtual ~GUIFactory() = default;
};
class WindowsFactory : public GUIFactory {
public:
std::unique_ptr<Button> createButton() override {
return std::make_unique<WindowsButton>();
}
std::unique_ptr<Checkbox> createCheckbox() override {
return std::make_unique<WindowsCheckbox>();
}
};
class MacFactory : public GUIFactory {
public:
std::unique_ptr<Button> createButton() override {
return std::make_unique<MacButton>();
}
std::unique_ptr<Checkbox> createCheckbox() override {
return std::make_unique<MacCheckbox>();
}
};
int main() {
std::unique_ptr<GUIFactory> factory;
#ifdef _WIN32
factory = std::make_unique<WindowsFactory>();
#else
factory = std::make_unique<MacFactory>();
#endif
auto button = factory->createButton();
auto checkbox = factory->createCheckbox();
button->render();
checkbox->render();
}4. 자동 등록 Factory
매크로 없이 자동 등록
다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 에러 처리를 통해 안정성을 확보합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
#include <memory>
#include <string>
#include <map>
#include <functional>
#include <iostream>
class Product {
public:
virtual void use() = 0;
virtual ~Product() = default;
};
class ProductA : public Product {
public:
void use() override {
std::cout << "Using Product A\n";
}
};
class ProductB : public Product {
public:
void use() override {
std::cout << "Using Product B\n";
}
};
// 자동 등록 Factory
class ProductFactory {
public:
using Creator = std::function<std::unique_ptr<Product>()>;
static void registerProduct(const std::string& type, Creator creator) {
registry()[type] = creator;
}
static std::unique_ptr<Product> create(const std::string& type) {
auto it = registry().find(type);
if (it != registry().end()) {
return it->second();
}
return nullptr;
}
private:
static std::map<std::string, Creator>& registry() {
static std::map<std::string, Creator> reg;
return reg;
}
};
// 자동 등록 헬퍼
template<typename T>
class AutoRegister {
public:
AutoRegister(const std::string& type) {
ProductFactory::registerProduct(type, {
return std::make_unique<T>();
});
}
};
// 전역 변수로 자동 등록
static AutoRegister<ProductA> registerA("A");
static AutoRegister<ProductB> registerB("B");
int main() {
auto product = ProductFactory::create("A");
if (product) {
product->use(); // "Using Product A"
}
}5. 자주 발생하는 문제와 해결법
문제 1: nullptr 처리 누락
증상: 크래시.
원인: Factory가 nullptr을 반환할 수 있는데 검사하지 않았습니다.
아래 코드는 cpp를 사용한 구현 예제입니다. 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
// ❌ 잘못된 사용: nullptr 검사 없음
auto product = Factory::create("unknown");
product->use(); // Crash: nullptr 역참조
// ✅ 올바른 사용: nullptr 검사
auto product = Factory::create("unknown");
if (product) {
product->use();
} else {
std::cerr << "Unknown product type\n";
}문제 2: 메모리 누수
증상: 메모리 누수.
원인: new로 생성한 객체를 delete하지 않았습니다.
아래 코드는 cpp를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.
// ❌ 잘못된 사용: raw pointer
Product* Factory::create(const std::string& type) {
return new ConcreteProduct(); // 누가 delete?
}
// ✅ 올바른 사용: unique_ptr
std::unique_ptr<Product> Factory::create(const std::string& type) {
return std::make_unique<ConcreteProduct>();
}문제 3: 확장성 부족
증상: 새 타입 추가 시 Factory 수정 필요.
원인: if-else 체인.
아래 코드는 cpp를 사용한 구현 예제입니다. 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
// ❌ 잘못된 사용: if-else 체인
std::unique_ptr<Product> Factory::create(const std::string& type) {
if (type == "A") return std::make_unique<ProductA>();
if (type == "B") return std::make_unique<ProductB>();
// 새 타입 추가 시 여기 수정
return nullptr;
}
// ✅ 올바른 사용: 등록 기반
// 자동 등록 Factory 사용 (위 예제 참조)6. 프로덕션 패턴
패턴 1: 파라미터화된 Factory
다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
#include <memory>
#include <string>
#include <iostream>
class Logger {
public:
virtual void log(const std::string& msg) = 0;
virtual ~Logger() = default;
};
class FileLogger : public Logger {
public:
FileLogger(const std::string& path) : filepath(path) {}
void log(const std::string& msg) override {
std::cout << "[File:" << filepath << "] " << msg << '\n';
}
private:
std::string filepath;
};
class LoggerFactory {
public:
static std::unique_ptr<Logger> createFileLogger(const std::string& path) {
return std::make_unique<FileLogger>(path);
}
};
int main() {
auto logger = LoggerFactory::createFileLogger("/var/log/app.log");
logger->log("Application started");
}패턴 2: 싱글톤 Factory
다음은 cpp를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
class Factory {
public:
static Factory& instance() {
static Factory inst;
return inst;
}
std::unique_ptr<Product> create(const std::string& type) {
auto it = creators.find(type);
if (it != creators.end()) {
return it->second();
}
return nullptr;
}
void registerCreator(const std::string& type, Creator creator) {
creators[type] = creator;
}
private:
Factory() = default;
std::map<std::string, Creator> creators;
};7. 완전한 예제: 플러그인 시스템
다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
#include <memory>
#include <string>
#include <map>
#include <functional>
#include <iostream>
class Plugin {
public:
virtual void execute() = 0;
virtual std::string getName() const = 0;
virtual ~Plugin() = default;
};
class PluginFactory {
public:
using Creator = std::function<std::unique_ptr<Plugin>()>;
static PluginFactory& instance() {
static PluginFactory inst;
return inst;
}
void registerPlugin(const std::string& name, Creator creator) {
creators_[name] = creator;
}
std::unique_ptr<Plugin> create(const std::string& name) {
auto it = creators_.find(name);
if (it != creators_.end()) {
return it->second();
}
std::cerr << "Plugin not found: " << name << '\n';
return nullptr;
}
void listPlugins() const {
std::cout << "Available plugins:\n";
for (const auto& [name, _] : creators_) {
std::cout << " - " << name << '\n';
}
}
private:
PluginFactory() = default;
std::map<std::string, Creator> creators_;
};
// 자동 등록 헬퍼
template<typename T>
class PluginRegistrar {
public:
PluginRegistrar(const std::string& name) {
PluginFactory::instance().registerPlugin(name, {
return std::make_unique<T>();
});
}
};
// 플러그인 구현
class ImagePlugin : public Plugin {
public:
void execute() override {
std::cout << "Processing image...\n";
}
std::string getName() const override {
return "ImagePlugin";
}
};
class VideoPlugin : public Plugin {
public:
void execute() override {
std::cout << "Processing video...\n";
}
std::string getName() const override {
return "VideoPlugin";
}
};
// 자동 등록
static PluginRegistrar<ImagePlugin> registerImage("image");
static PluginRegistrar<VideoPlugin> registerVideo("video");
int main() {
PluginFactory::instance().listPlugins();
auto plugin = PluginFactory::instance().create("image");
if (plugin) {
std::cout << "Loaded: " << plugin->getName() << '\n';
plugin->execute();
}
}출력: 아래 코드는 code를 사용한 구현 예제입니다. 코드를 직접 실행해보면서 동작을 확인해보세요.
Available plugins:
- image
- video
Loaded: ImagePlugin
Processing image...정리
| 패턴 | 설명 |
|---|---|
| Simple Factory | 정적 메서드로 객체 생성 |
| Factory Method | 상속으로 팩토리 확장 |
| Abstract Factory | 관련 객체 군 생성 |
| 자동 등록 Factory | 전역 변수로 타입 자동 등록 |
| 장점 | 캡슐화, 확장성, 의존성 역전 |
| 단점 | 클래스 증가, 복잡도 증가 |
| Factory Pattern은 객체 생성 로직을 캡슐화해 확장성과 유지보수성을 높이는 핵심 디자인 패턴입니다. |
FAQ
Q1: Factory Pattern은 언제 쓰나요?
A: 객체 생성 로직이 복잡하거나, 새 타입 추가가 빈번하거나, 클라이언트가 구체 클래스에 의존하지 않아야 할 때 사용합니다.
Q2: Simple Factory vs Factory Method?
A: Simple Factory는 정적 메서드로 간단하고, Factory Method는 상속으로 확장 가능합니다.
Q3: Abstract Factory는 언제 쓰나요?
A: 관련 객체 군을 함께 생성해야 할 때 (예: Windows UI vs Mac UI).
Q4: 자동 등록 Factory의 장점은?
A: 새 타입 추가 시 Factory 수정 불필요, 전역 변수로 자동 등록됩니다.
Q5: 단점은?
A: 클래스 수 증가, 간접 참조로 복잡도 증가.
Q6: Factory Pattern 학습 리소스는?
A:
- “Design Patterns” by Gang of Four
- “Head First Design Patterns” by Freeman & Freeman
- Refactoring Guru: Factory Pattern 한 줄 요약: Factory Pattern으로 객체 생성 로직을 캡슐화하고 확장성을 높일 수 있습니다. 다음으로 Observer Pattern을 읽어보면 좋습니다.
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.
- C++ 가상 함수 | “Virtual Functions” 가이드
- C++ 스마트 포인터 | unique_ptr/shared_ptr “메모리 안전” 가이드
- C++ Observer Pattern 완벽 가이드 | 이벤트 기반 아키텍처와 신호/슬롯