C++ Factory Pattern 완벽 가이드 | 객체 생성 캡슐화와 확장성

· 19분 읽기 · 수정 중급 튜토리얼
C++ Factory Pattern 완벽 가이드 | 객체 생성 캡슐화와 확장성

이 글의 핵심

C++ Factory Pattern 완벽 가이드에 대한 실전 가이드입니다. 객체 생성 캡슐화와 확장성 등을 예제와 함께 상세히 설명합니다.

Factory Pattern이란? 왜 필요한가

문제 시나리오: 객체 생성 로직의 중복과 의존성

문제: 클라이언트 코드가 구체 클래스에 직접 의존하면, 새 타입 추가 시 모든 클라이언트 코드를 수정해야 합니다.

// 클라이언트 코드 (나쁜 예)
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가 구체 클래스를 결정합니다.

// 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만 수정
flowchart TD
    client["Client"]
    factory["LoggerFactory create(type)"]
    console["ConsoleLogger"]
    file["FileLogger"]
    network["NetworkLogger"]
    
    client --> factory
    factory --> console
    factory --> file
    factory --> network

목차

  1. Simple Factory
  2. Factory Method
  3. Abstract Factory
  4. 자동 등록 Factory
  5. 자주 발생하는 문제와 해결법
  6. 프로덕션 패턴
  7. 완전한 예제: 플러그인 시스템

1. Simple Factory

기본 구조

#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

팩토리를 상속으로 확장

#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

관련 객체 군 생성

#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

매크로 없이 자동 등록

#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을 반환할 수 있는데 검사하지 않았습니다.

// ❌ 잘못된 사용: 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하지 않았습니다.

// ❌ 잘못된 사용: 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 체인.

// ❌ 잘못된 사용: 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

#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

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. 완전한 예제: 플러그인 시스템

#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();
    }
}

출력:

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:

한 줄 요약: Factory Pattern으로 객체 생성 로직을 캡슐화하고 확장성을 높일 수 있습니다. 다음으로 Observer Pattern을 읽어보면 좋습니다.

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

  • C++ 가상 함수 | “Virtual Functions” 가이드
  • C++ 스마트 포인터 | unique_ptr/shared_ptr “메모리 안전” 가이드
  • C++ Observer Pattern 완벽 가이드 | 이벤트 기반 아키텍처와 신호/슬롯

관련 글

  • C++ CRTP 완벽 가이드 | 정적 다형성과 컴파일 타임 최적화
  • C++ Strategy Pattern 완벽 가이드 | 알고리즘 캡슐화와 런타임 교체
  • C++ Visitor Pattern |
  • C++ Adapter Pattern 완벽 가이드 | 인터페이스 변환과 호환성
  • C++ Command Pattern 완벽 가이드 | 실행 취소와 매크로 시스템