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

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

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

이 글의 핵심

C++ Factory Pattern : 객체 생성 캡슐화와 확장성. Factory Pattern이란?. 왜 필요한가·Simple Factory.

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

기본 구조

#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:

  • “Design Patterns” by Gang of Four
  • “Head First Design Patterns” by Freeman & Freeman
  • Refactoring Guru: Factory Pattern 한 줄 요약: Factory Pattern으로 객체 생성 로직을 캡슐화하고 확장성을 높일 수 있습니다. 다음으로 Observer Pattern을 읽어보면 좋습니다.

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

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

관련 글

심화 부록: 구현·운영 관점

이 부록은 앞선 본문에서 다룬 주제(「C++ Factory Pattern 완벽 가이드 | 객체 생성 캡슐화와 확장성」)를 구현·런타임·운영 관점에서 다시 압축합니다. 도메인별 세부 구현은 글마다 다르지만, 입력 검증 → 핵심 연산 → 부작용(I/O·네트워크·동시성) → 관측의 흐름으로 장애를 나누면 원인 추적이 빨라집니다.

내부 동작과 핵심 메커니즘

flowchart TD
  A[입력·요청·이벤트] --> B[파싱·검증·디코딩]
  B --> C[핵심 연산·상태 전이]
  C --> D[부작용: I/O·네트워크·동시성]
  D --> E[결과·관측·저장]
sequenceDiagram
  participant C as 클라이언트/호출자
  participant B as 경계(런타임·게이트웨이·프로세스)
  participant D as 의존성(API·DB·큐·파일)
  C->>B: 요청/이벤트
  B->>D: 조회·쓰기·RPC
  D-->>B: 지연·부분 실패·재시도 가능
  B-->>C: 응답 또는 오류(코드·상관 ID)
  • 불변 조건(Invariant): 버퍼 경계, 프로토콜 상태, 트랜잭션 격리, FD 상한 등 단계별로 문장으로 적어 두면 디버깅 비용이 줄어듭니다.
  • 결정성: 순수 층과 시간·네트워크·스케줄에 의존하는 층을 분리해야 테스트와 장애 분석이 쉬워집니다.
  • 경계 비용: 직렬화, 인코딩, syscall 횟수, 락 경합, 할당·GC, 캐시 미스를 의심 목록에 둡니다.
  • 백프레셔: 생산자가 소비자보다 빠를 때 버퍼·큐·스트림에서 속도를 줄이는 신호를 어디에 둘지 정의합니다.

프로덕션 운영 패턴

영역운영 관점 질문
관측성요청 단위 상관 ID, 에러율·지연 p95/p99, 의존성 타임아웃·재시도가 대시보드에 보이는가
안전성입력 검증·권한·비밀·감사 로그가 코드 경로마다 일관적인가
신뢰성재시도는 멱등 연산에만 적용되는가, 서킷 브레이커·백오프·DLQ가 있는가
성능캐시·배치 크기·커넥션 풀·인덱스·백프레셔가 데이터 규모에 맞는가
배포롤백 룬북, 카나리/블루그린, 마이그레이션·피처 플래그가 문서화되어 있는가
용량피크 트래픽·디스크·FD·스레드 풀 상한을 주기적으로 검증하는가

스테이징은 데이터 양·네트워크 RTT·동시성을 프로덕션에 가깝게 맞출수록 재현율이 올라갑니다.

확장 예시: 엔드투엔드 미니 시나리오

앞선 본문 주제(「C++ Factory Pattern 완벽 가이드 | 객체 생성 캡슐화와 확장성」)를 배포·운영 흐름에 맞춰 옮긴 체크리스트입니다. 도메인에 맞게 단계 이름만 바꿔 적용할 수 있습니다.

  1. 입력 계약 고정: 스키마·버전·최대 페이로드·타임아웃·에러 코드를 경계에 둔다.
  2. 핵심 경로 계측: 요청 ID, 단계별 지연, 외부 호출 결과 코드를 로그·메트릭·트레이스에서 한 흐름으로 본다.
  3. 실패 주입: 의존성 타임아웃·5xx·부분 데이터·락 대기를 스테이징에서 재현한다.
  4. 호환·롤백: 설정/마이그레이션/클라이언트 버전을 되돌릴 수 있는지 확인한다.
  5. 부하 후 검증: 피크 대비 p95/p99, 에러율, 리소스 상한, 알림 임계값을 점검한다.
handle(request):
  ctx = newCorrelationId()
  validated = validateSchema(request)
  authorize(validated, ctx)
  result = domainCore(validated)
  persistOrEmit(result, idempotentKey)
  recordMetrics(ctx, latency, outcome)
  return result

문제 해결(Troubleshooting)

증상가능 원인조치
간헐적 실패레이스, 타임아웃, 외부 의존성, DNS최소 재현 스크립트, 분산 트레이스·로그 상관관계, 재시도·서킷 설정 점검
성능 저하N+1, 동기 I/O, 락 경합, 과도한 직렬화, 캐시 미스프로파일러·APM으로 핫스팟 확인 후 한 가지씩 제거
메모리 증가캐시 무제한, 구독/리스너 누수, 대용량 버퍼, 커넥션 미반납상한·TTL·힙/FD 스냅샷 비교
빌드·배포만 실패환경 변수, 권한, 플랫폼 차이, lockfileCI 로그와 로컬 diff, 런타임·이미지 버전 핀
설정 불일치프로필·시크릿·기본값, 리전스키마 검증된 설정 단일 소스와 배포 매트릭스 표준화
데이터 불일치비멱등 재시도, 부분 쓰기, 캐시 무효화 누락멱등 키·아웃박스·트랜잭션 경계 재검토

권장 순서: (1) 최소 재현 (2) 최근 변경 범위 축소 (3) 환경·의존성 차이 (4) 관측으로 가설 검증 (5) 수정 후 회귀·부하 테스트.

배포 전에는 git add → git commit → git push 후 npm run deploy 순서를 권장합니다.

이 글에서 다루는 키워드 (관련 검색어)

C++, factory, pattern, creational, design, polymorphism 등으로 검색하시면 이 글이 도움이 됩니다.