C++ 디자인 패턴: 싱글톤, 팩토리, 옵저버 🚀

안녕하세요, 코딩 덕후 여러분! 오늘은 C++의 세계에서 꼭 알아야 할 디자인 패턴 삼총사에 대해 얘기해볼게요. 싱글톤, 팩토리, 옵저버... 이름만 들어도 뭔가 있어 보이죠? ㅋㅋㅋ 근데 걱정 마세요. 어려워 보여도 제가 쉽게 설명해드릴게요! 😉

이 글을 읽다 보면 여러분도 어느새 디자인 패턴 마스터가 되어 있을 거예요. 마치 재능넷에서 고수의 재능을 배우듯이 말이죠! 그럼 우리 함께 C++의 디자인 패턴 세계로 떠나볼까요? 🚀

1. 싱글톤 패턴 (Singleton Pattern) 🏠

자, 여러분! 싱글톤 패턴이 뭔지 아세요? 간단히 말하면, 클래스의 인스턴스가 오직 하나만 생성되도록 보장하는 패턴이에요. 마치 여러분의 집에 하나뿐인 냉장고처럼 말이죠! 🏠❄️

싱글톤 패턴은 왜 필요할까요? 예를 들어볼게요:

• 프로그램 전체에서 공유해야 하는 리소스 관리 (예: 데이터베이스 연결)
• 전역 상태를 유지해야 하는 경우 (예: 애플리케이션 설정)
• 오직 하나의 인스턴스만 존재해야 하는 객체 (예: 로깅 시스템)

이제 C++로 싱글톤 패턴을 구현해볼까요? 코드를 보면서 설명드릴게요!

class Singleton {
private:
    static Singleton* instance;
    Singleton() {} // private 생성자

public:
    static Singleton* getInstance() {
        if (instance == nullptr) {
            instance = new Singleton();
        }
        return instance;
    }

    void showMessage() {
        std::cout << "안녕하세요, 저는 싱글톤이에요!" << std::endl;
    }
};

// 정적 멤버 초기화
Singleton* Singleton::instance = nullptr;

이 코드를 보면 몇 가지 특징이 있어요:

1. private 생성자: 외부에서 직접 객체를 생성할 수 없게 해요.
2. static 인스턴스: 클래스의 유일한 인스턴스를 저장해요.
3. getInstance() 메서드: 인스턴스가 없으면 생성하고, 있으면 기존 인스턴스를 반환해요.

이렇게 하면 어떤 장점이 있을까요? 🤔

하지만 모든 것이 장점만 있는 건 아니죠. 싱글톤 패턴에도 단점이 있어요:

자, 이제 싱글톤 패턴에 대해 어느 정도 감이 오시나요? 🤓 이 패턴은 정말 유용하지만, 남용하면 안 돼요. 꼭 필요한 경우에만 사용하는 게 좋답니다!

그럼 이제 싱글톤 패턴을 실제로 어떻게 사용하는지 예제를 통해 살펴볼까요?

int main() {
    Singleton* s1 = Singleton::getInstance();
    Singleton* s2 = Singleton::getInstance();

    s1->showMessage();  // 출력: 안녕하세요, 저는 싱글톤이에요!
    s2->showMessage();  // 출력: 안녕하세요, 저는 싱글톤이에요!

    if (s1 == s2) {
        std::cout << "s1과 s2는 같은 인스턴스를 가리킵니다!" << std::endl;
    }

    return 0;
}

이 예제를 실행하면, s1과 s2가 같은 인스턴스를 가리키는 것을 확인할 수 있어요. 이게 바로 싱글톤의 핵심이죠!

싱글톤 패턴은 재능넷 같은 플랫폼에서도 유용하게 쓰일 수 있어요. 예를 들어, 사용자 세션 관리나 전역 설정 관리 등에 활용될 수 있죠. 하나의 인스턴스로 모든 사용자의 정보를 관리하면 효율적이겠죠? 😎

이 다이어그램을 보면 싱글톤 패턴의 구조를 한눈에 이해할 수 있죠? Client(사용자)는 Singleton 클래스의 getInstance() 메서드를 통해 유일한 인스턴스에 접근합니다. 그리고 그 인스턴스는 계속해서 재사용되는 거예요. 👍

자, 이제 싱글톤 패턴에 대해 꽤 자세히 알아봤네요. 어때요? 생각보다 어렵지 않죠? ㅎㅎ 이제 여러분도 싱글톤 패턴을 사용할 준비가 됐어요! 🎉

다음으로 넘어가기 전에, 한 가지 팁을 더 드릴게요. C++11 이후 버전에서는 더 안전한 싱글톤 구현 방법이 있어요. 바로 'Meyer's Singleton'이라고 불리는 방식이에요.

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton instance;
        return instance;
    }

    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;

private:
    Singleton() = default;
};

이 방식은 몇 가지 장점이 있어요:

• 스레드 안전성: C++11 표준은 정적 지역 변수의 초기화가 스레드 안전함을 보장해요.
• 자동 메모리 관리: 동적 할당을 사용하지 않아 메모리 누수 걱정이 없어요.
• 간결한 코드: 더 짧고 명확한 코드로 싱글톤을 구현할 수 있어요.

이렇게 C++의 최신 기능을 활용하면 더 안전하고 효율적인 싱글톤을 만들 수 있답니다. 여러분도 프로젝트에서 한번 시도해보세요! 😊

자, 이제 정말 싱글톤 패턴 마스터가 다 됐네요! 다음은 팩토리 패턴으로 넘어가볼까요? 🚀

2. 팩토리 패턴 (Factory Pattern) 🏭

안녕하세요, 코딩 친구들! 이제 우리의 두 번째 주인공, 팩토리 패턴을 만나볼 시간이에요. 팩토리라고 하니까 뭔가 공장 같은 게 떠오르지 않나요? ㅋㅋㅋ 실제로 이 패턴은 객체를 생성하는 '공장' 역할을 한답니다! 😎

팩토리 패턴은 객체 생성 로직을 캡슐화하여 코드의 유연성과 재사용성을 높이는 생성 패턴이에요. 쉽게 말해, 객체를 만드는 방법을 따로 빼서 관리하는 거죠.

자, 그럼 팩토리 패턴의 종류를 살펴볼까요? 크게 세 가지로 나눌 수 있어요:

1. 심플 팩토리 (Simple Factory): 가장 기본적인 형태의 팩토리 패턴
2. 팩토리 메서드 (Factory Method): 객체 생성을 서브클래스에 위임하는 패턴
3. 추상 팩토리 (Abstract Factory): 관련된 객체들의 family를 생성하는 패턴

오늘은 이 중에서 팩토리 메서드 패턴을 자세히 살펴볼 거예요. 준비되셨나요? Let's go! 🚀

팩토리 메서드 패턴 (Factory Method Pattern)

팩토리 메서드 패턴은 객체 생성을 처리하는 인터페이스를 정의하지만, 어떤 클래스의 인스턴스를 생성할지는 서브클래스가 결정하도록 해요. 음... 뭔가 어려워 보이죠? 걱정 마세요, 예제를 통해 쉽게 설명해드릴게요! 😉

우리가 피자 가게를 운영한다고 상상해볼까요? 🍕 여러 종류의 피자를 만들어야 하는데, 각 피자마다 만드는 방법이 조금씩 다르답니다. 이럴 때 팩토리 메서드 패턴을 사용하면 아주 유용해요!

// 피자 추상 클래스
class Pizza {
public:
    virtual void prepare() = 0;
    virtual void bake() = 0;
    virtual void cut() = 0;
    virtual void box() = 0;
    virtual ~Pizza() {}
};

// 구체적인 피자 클래스들
class CheesePizza : public Pizza {
public:
    void prepare() override { std::cout << "치즈 피자 준비 중..." << std::endl; }
    void bake() override { std::cout << "치즈 피자 굽는 중..." << std::endl; }
    void cut() override { std::cout << "치즈 피자 자르는 중..." << std::endl; }
    void box() override { std::cout << "치즈 피자 포장 중..." << std::endl; }
};

class PepperoniPizza : public Pizza {
public:
    void prepare() override { std::cout << "페퍼로니 피자 준비 중..." << std::endl; }
    void bake() override { std::cout << "페퍼로니 피자 굽는 중..." << std::endl; }
    void cut() override { std::cout << "페퍼로니 피자 자르는 중..." << std::endl; }
    void box() override { std::cout << "페퍼로니 피자 포장 중..." << std::endl; }
};

// 피자 팩토리 추상 클래스
class PizzaFactory {
public:
    virtual Pizza* createPizza(std::string type) = 0;
    virtual ~PizzaFactory() {}
};

// 구체적인 피자 팩토리 클래스
class SimplePizzaFactory : public PizzaFactory {
public:
    Pizza* createPizza(std::string type) override {
        Pizza* pizza = nullptr;
        if (type == "cheese") {
            pizza = new CheesePizza();
        } else if (type == "pepperoni") {
            pizza = new PepperoniPizza();
        }
        return pizza;
    }
};

// 피자 가게 클래스
class PizzaStore {
private:
    PizzaFactory* factory;

public:
    PizzaStore(PizzaFactory* factory) : factory(factory) {}

    Pizza* orderPizza(std::string type) {
        Pizza* pizza = factory->createPizza(type);
        
        pizza->prepare();
        pizza->bake();
        pizza->cut();
        pizza->box();

        return pizza;
    }
};

우와, 코드가 좀 길죠? 하지만 걱정 마세요. 하나씩 뜯어보면 생각보다 간단해요! 😊

1. Pizza 클래스: 모든 피자의 기본이 되는 추상 클래스예요.
2. CheesePizza, PepperoniPizza: 구체적인 피자 종류를 나타내는 클래스들이에요.
3. PizzaFactory: 피자를 만드는 팩토리의 추상 클래스예요.
4. SimplePizzaFactory: 실제로 피자를 만드는 구체적인 팩토리 클래스예요.
5. PizzaStore: 피자를 주문받고 만드는 과정을 관리하는 클래스예요.

이제 이 코드를 어떻게 사용하는지 볼까요?

int main() {
    PizzaFactory* factory = new SimplePizzaFactory();
    PizzaStore* store = new PizzaStore(factory);

    Pizza* cheesePizza = store->orderPizza("cheese");
    std::cout << "치즈 피자 주문 완료!" << std::endl;

    std::cout << std::endl;

    Pizza* pepperoniPizza = store->orderPizza("pepperoni");
    std::cout << "페퍼로니 피자 주문 완료!" << std::endl;

    delete cheesePizza;
    delete pepperoniPizza;
    delete store;
    delete factory;

    return 0;
}

이렇게 하면 각각 다른 종류의 피자를 쉽게 주문할 수 있어요. 그리고 나중에 새로운 피자 종류를 추가하고 싶다면? 그냥 새로운 피자 클래스를 만들고 팩토리에 추가하면 끝이에요! 👍

하지만 모든 것이 장점만 있는 건 아니겠죠? 팩토리 메서드 패턴에도 단점이 있어요:

자, 이제 팩토리 메서드 패턴에 대해 꽤 자세히 알아봤네요. 어때요? 생각보다 재밌죠? ㅎㅎ

이 패턴은 재능넷 같은 플랫폼에서도 유용하게 쓰일 수 있어요. 예를 들어, 다양한 종류의 재능 거래를 생성하는 데 사용할 수 있죠. 프로그래밍 재능, 디자인 재능, 음악 재능 등 각각 다른 특성을 가진 재능 거래를 생성할 때 팩토리 메서드 패턴을 적용하면 코드를 더 깔끔하고 확장 가능하게 만들 수 있어요. 😎

이 다이어그램을 보면 팩토리 메서드 패턴의 구조를 한눈에 이해할 수 있죠? Creator는 팩토리 메서드를 정의하고, ConcreteCreator는 이를 구현해요. 그리고 ConcreteCreator는 ConcreteProduct를 생성하는 역할을 하죠. 이렇게 하면 객체 생성 로직을 캡슐화하고 유연성을 높일 수 있어요. 👍

자, 이제 팩토리 메서드 패턴에 대해 꽤 자세히 알아봤네요. 어때요? 생각보다 어렵지 않죠? ㅎㅎ 이제 여러분도 팩토리 메서드 패턴을 사용할 준비가 됐어요! 🎉

팩토리 메서드 패턴은 정말 유용하지만, 상황에 따라 다른 패턴이 더 적합할 수도 있어요. 항상 여러분의 프로젝트 요구사항을 잘 분석하고, 가장 적절한 패턴을 선택하는 것이 중요해요.

자, 이제 우리의 마지막 주인공인 옵저버 패턴으로 넘어갈 준비가 됐나요? 가즈아 네, 계속해서 옵저버 패턴에 대해 설명드리겠습니다.

#include <iostream>
#include <vector>
#include <algorithm>

// Observer 인터페이스
class Observer {
public:
    virtual void update(const std::string& message) = 0;
    virtual ~Observer() {}
};

// Subject 클래스
class TalentSubject {
private:
    std::vector<Observer*> observers;
    std::string latestTalent;

public:
    void registerObserver(Observer* observer) {
        observers.push_back(observer);
    }

    void removeObserver(Observer* observer) {
        observers.erase(std::remove(observers.begin(), observers.end(), observer), observers.end());
    }

    void notifyObservers() {
        for (Observer* observer : observers) {
            observer->update(latestTalent);
        }
    }

    void setNewTalent(const std::string& talent) {
        latestTalent = talent;
        notifyObservers();
    }
};

// ConcreteObserver 클래스
class User : public Observer {
private:
    std::string name;

public:
    User(const std::string& name) : name(name) {}

    void update(const std::string& message) override {
        std::cout << name << "님, 새로운 재능이 등록되었습니다: " << message << std::endl;
    }
};

int main() {
    TalentSubject talentPlatform;

    User* user1 = new User("Alice");
    User* user2 = new User("Bob");
    User* user3 = new User("Charlie");

    talentPlatform.registerObserver(user1);
    talentPlatform.registerObserver(user2);
    talentPlatform.registerObserver(user3);

    talentPlatform.setNewTalent("C++ 프로그래밍");

    talentPlatform.removeObserver(user2);

    talentPlatform.setNewTalent("디자인 패턴 강의");

    delete user1;
    delete user2;
    delete user3;

    return 0;
}

Alice님, 새로운 재능이 등록되었습니다: C++ 프로그래밍
Bob님, 새로운 재능이 등록되었습니다: C++ 프로그래밍
Charlie님, 새로운 재능이 등록되었습니다: C++ 프로그래밍
Alice님, 새로운 재능이 등록되었습니다: 디자인 패턴 강의
Charlie님, 새로운 재능이 등록되었습니다: 디자인 패턴 강의