[2026] C++ Observer Pattern 완벽 가이드 | 이벤트 기반 아키텍처와 신호/슬롯
![[2026] C++ Observer Pattern 완벽 가이드 | 이벤트 기반 아키텍처와 신호/슬롯](/og/s/cpp-observer-pattern.webp)
이 글의 핵심
C++ Observer Pattern : 이벤트 기반 아키텍처와 신호/슬롯. Observer Pattern이란?. 왜 필요한가·기본 구조.
Observer Pattern이란? 왜 필요한가
브라우저·Node에서는 JavaScript 옵저버·이벤트 패턴으로 같은 결합도 문제를 푸는 경우가 많습니다. C++ 쪽 행동 패턴 묶음은 행동 패턴 시리즈와 함께 보면 좋습니다.
문제 시나리오: 상태 변경 알림
문제: 데이터 모델이 변경되면, 여러 UI 컴포넌트를 업데이트해야 합니다. 각 컴포넌트를 직접 호출하면 강한 결합이 생깁니다. 다음은 cpp를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
// 나쁜 예: 강한 결합
// 타입 정의
class DataModel {
public:
void setValue(int v) {
value = v;
// UI 컴포넌트를 직접 호출
chart->update(value);
label->update(value);
logger->log(value);
}
private:
int value;
Chart* chart;
Label* label;
Logger* logger;
};문제점:
- 강한 결합:
DataModel이 모든 UI 컴포넌트를 알아야 함 - 확장 어려움: 새 컴포넌트 추가 시
DataModel수정 필요 - 재사용 불가:
DataModel을 다른 프로젝트에서 재사용 어려움 해결: Observer Pattern은 Subject(관찰 대상)와 Observer(관찰자)를 분리합니다. Subject는 Observer 목록만 관리하고, 상태 변경 시 notify()로 알립니다. 다음은 cpp를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
// 좋은 예: 느슨한 결합
// 타입 정의
class DataModel {
public:
void setValue(int v) {
value = v;
notify(value); // 모든 Observer에 알림
}
void attach(std::shared_ptr<Observer> obs) {
observers.push_back(obs);
}
private:
int value;
std::vector<std::weak_ptr<Observer>> observers;
void notify(int value) {
for (auto& obs : observers) {
if (auto ptr = obs.lock()) {
ptr->update(value);
}
}
}
};아래 코드는 mermaid를 사용한 구현 예제입니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
// 실행 예제
flowchart TD
subject["Subject (DataModel)"]
obs1["Observer 1 (Chart)"]
obs2["Observer 2 (Label)"]
obs3["Observer 3 (Logger)"]
subject -->|notify| obs1
subject -->|notify| obs2
subject -->|notify| obs3
obs1 -.->|attach| subject
obs2 -.->|attach| subject
obs3 -.->|attach| subject
목차
1. 기본 구조
최소 Observer
다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
#include <iostream>
#include <vector>
#include <memory>
class Observer {
public:
virtual void update(int value) = 0;
virtual ~Observer() = default;
};
class Subject {
public:
void attach(std::shared_ptr<Observer> obs) {
observers.push_back(obs);
}
void notify(int value) {
for (auto& obs : observers) {
obs->update(value);
}
}
private:
std::vector<std::shared_ptr<Observer>> observers;
};
class ConcreteObserver : public Observer {
public:
ConcreteObserver(const std::string& name) : name_(name) {}
void update(int value) override {
std::cout << name_ << " received: " << value << '\n';
}
private:
std::string name_;
};
int main() {
Subject subject;
auto obs1 = std::make_shared<ConcreteObserver>("Observer1");
auto obs2 = std::make_shared<ConcreteObserver>("Observer2");
subject.attach(obs1);
subject.attach(obs2);
subject.notify(42);
// Observer1 received: 42
// Observer2 received: 42
}2. weak_ptr로 메모리 누수 방지
문제: 순환 참조
아래 코드는 cpp를 사용한 구현 예제입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며. 코드를 직접 실행해보면서 동작을 확인해보세요.
// ❌ 잘못된 사용: shared_ptr로 순환 참조
class Subject {
std::vector<std::shared_ptr<Observer>> observers; // 강한 참조
};
// Subject가 Observer를 소유, Observer가 Subject를 소유 → 순환 참조해결: weak_ptr
다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
#include <iostream>
#include <vector>
#include <memory>
class Observer {
public:
virtual void update(int value) = 0;
virtual ~Observer() = default;
};
class Subject {
public:
void attach(std::shared_ptr<Observer> obs) {
observers.push_back(obs); // weak_ptr로 저장
}
void notify(int value) {
// 만료된 Observer 제거
observers.erase(
std::remove_if(observers.begin(), observers.end(),
{
return wp.expired();
}),
observers.end()
);
// 알림
for (auto& obs : observers) {
if (auto ptr = obs.lock()) {
ptr->update(value);
}
}
}
private:
std::vector<std::weak_ptr<Observer>> observers;
};
class ConcreteObserver : public Observer {
public:
ConcreteObserver(const std::string& name) : name_(name) {}
~ConcreteObserver() {
std::cout << name_ << " destroyed\n";
}
void update(int value) override {
std::cout << name_ << " received: " << value << '\n';
}
private:
std::string name_;
};
int main() {
Subject subject;
{
auto obs1 = std::make_shared<ConcreteObserver>("Observer1");
subject.attach(obs1);
subject.notify(42); // Observer1 received: 42
} // obs1 소멸
subject.notify(100); // 만료된 Observer는 알림 안 받음
}출력:
Observer1 received: 42
Observer1 destroyed일상 비유로 이해하기: 메모리를 아파트 건물로 생각해보세요. 스택은 엘리베이터 같아서 빠르지만 공간이 제한적입니다. 힙은 창고처럼 넓지만 물건을 찾는 데 시간이 걸립니다. 포인터는 “3층 302호”처럼 주소를 가리키는 메모지라고 보면 됩니다.
3. 이벤트 타입별 Observer
다양한 이벤트 처리
다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
#include <iostream>
#include <vector>
#include <memory>
#include <string>
class Event {
public:
virtual ~Event() = default;
};
class ValueChangedEvent : public Event {
public:
ValueChangedEvent(int v) : value(v) {}
int value;
};
class ErrorEvent : public Event {
public:
ErrorEvent(const std::string& m) : message(m) {}
std::string message;
};
class Observer {
public:
virtual void onEvent(const Event& event) = 0;
virtual ~Observer() = default;
};
class Subject {
public:
void attach(std::shared_ptr<Observer> obs) {
observers.push_back(obs);
}
void notifyEvent(const Event& event) {
for (auto& obs : observers) {
if (auto ptr = obs.lock()) {
ptr->onEvent(event);
}
}
}
private:
std::vector<std::weak_ptr<Observer>> observers;
};
class ConcreteObserver : public Observer {
public:
void onEvent(const Event& event) override {
if (auto* ve = dynamic_cast<const ValueChangedEvent*>(&event)) {
std::cout << "Value changed: " << ve->value << '\n';
} else if (auto* ee = dynamic_cast<const ErrorEvent*>(&event)) {
std::cout << "Error: " << ee->message << '\n';
}
}
};
int main() {
Subject subject;
auto obs = std::make_shared<ConcreteObserver>();
subject.attach(obs);
subject.notifyEvent(ValueChangedEvent(42));
subject.notifyEvent(ErrorEvent("Something went wrong"));
}4. 신호/슬롯 패턴
Qt 스타일 신호/슬롯
다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
#include <iostream>
#include <vector>
#include <functional>
template<typename....Args>
class Signal {
public:
using Slot = std::function<void(Args...)>;
void connect(Slot slot) {
slots.push_back(slot);
}
void emit(Args....args) {
for (auto& slot : slots) {
slot(args...);
}
}
private:
std::vector<Slot> slots;
};
class Button {
public:
Signal<> clicked;
void click() {
std::cout << "Button clicked\n";
clicked.emit();
}
};
int main() {
Button button;
button.clicked.connect( {
std::cout << "Handler 1: Button was clicked\n";
});
button.clicked.connect( {
std::cout << "Handler 2: Logging click event\n";
});
button.click();
// Button clicked
// Handler 1: Button was clicked
// Handler 2: Logging click event
}5. 자주 발생하는 문제와 해결법
문제 1: 순환 참조
증상: 메모리 누수.
원인: Subject와 Observer가 서로 shared_ptr로 참조.
아래 코드는 cpp를 사용한 구현 예제입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며. 코드를 직접 실행해보면서 동작을 확인해보세요.
// ❌ 잘못된 사용: shared_ptr로 순환 참조
class Subject {
std::vector<std::shared_ptr<Observer>> observers;
};
// ✅ 올바른 사용: weak_ptr
class Subject {
std::vector<std::weak_ptr<Observer>> observers;
};문제 2: 알림 중 Observer 제거
증상: Iterator 무효화, 크래시.
원인: notify() 중에 Observer가 detach()를 호출.
다음은 cpp를 활용한 상세한 구현 코드입니다. 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
// ❌ 잘못된 사용: 알림 중 제거
void notify() {
for (auto& obs : observers) {
obs->update(); // update()에서 detach() 호출 → iterator 무효화
}
}
// ✅ 올바른 사용: 복사본으로 알림
void notify() {
auto copy = observers; // 복사
for (auto& obs : copy) {
if (auto ptr = obs.lock()) {
ptr->update();
}
}
}문제 3: 재진입
증상: 무한 루프.
원인: Observer의 update()에서 Subject의 setValue()를 호출 → 다시 notify().
다음은 cpp를 활용한 상세한 구현 코드입니다. 클래스를 정의하여 데이터와 기능을 캡슐화하며, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
// ❌ 잘못된 사용: 재진입
void Observer::update(int value) {
subject->setValue(value + 1); // 무한 루프
}
// ✅ 올바른 사용: 재진입 방지
class Subject {
void notify() {
if (notifying) return; // 재진입 방지
notifying = true;
// ....알림 ...
notifying = false;
}
private:
bool notifying = false;
};6. 프로덕션 패턴
패턴 1: 우선순위 Observer
다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
#include <map>
#include <memory>
class Subject {
public:
void attach(std::shared_ptr<Observer> obs, int priority = 0) {
observers[priority].push_back(obs);
}
void notify(int value) {
// 우선순위 높은 순서대로 알림
for (auto it = observers.rbegin(); it != observers.rend(); ++it) {
for (auto& obs : it->second) {
if (auto ptr = obs.lock()) {
ptr->update(value);
}
}
}
}
private:
std::map<int, std::vector<std::weak_ptr<Observer>>> observers;
};패턴 2: 비동기 알림
다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
#include <thread>
#include <future>
class Subject {
public:
void notifyAsync(int value) {
auto copy = observers;
std::thread([copy, value]() {
for (auto& obs : copy) {
if (auto ptr = obs.lock()) {
ptr->update(value);
}
}
}).detach();
}
private:
std::vector<std::weak_ptr<Observer>> observers;
};7. 완전한 예제: 주식 시장 모니터
다음은 cpp를 활용한 상세한 구현 코드입니다. 필요한 모듈을 import하고, 클래스를 정의하여 데이터와 기능을 캡슐화하며, 반복문으로 데이터를 처리합니다, 조건문으로 분기 처리를 수행합니다. 각 부분의 역할을 이해하면서 코드를 살펴보시기 바랍니다.
#include <iostream>
#include <vector>
#include <memory>
#include <string>
#include <algorithm>
class StockObserver {
public:
virtual void onPriceChanged(const std::string& symbol, double price) = 0;
virtual ~StockObserver() = default;
};
class StockMarket {
public:
void attach(std::shared_ptr<StockObserver> obs) {
observers.push_back(obs);
}
void detach(std::shared_ptr<StockObserver> obs) {
observers.erase(
std::remove_if(observers.begin(), observers.end(),
[&obs](const std::weak_ptr<StockObserver>& wp) {
auto sp = wp.lock();
return !sp || sp == obs;
}),
observers.end()
);
}
void setPrice(const std::string& symbol, double price) {
prices[symbol] = price;
notifyPriceChanged(symbol, price);
}
private:
std::map<std::string, double> prices;
std::vector<std::weak_ptr<StockObserver>> observers;
void notifyPriceChanged(const std::string& symbol, double price) {
auto copy = observers;
for (auto& obs : copy) {
if (auto ptr = obs.lock()) {
ptr->onPriceChanged(symbol, price);
}
}
}
};
class PriceDisplay : public StockObserver {
public:
PriceDisplay(const std::string& name) : name_(name) {}
void onPriceChanged(const std::string& symbol, double price) override {
std::cout << "[" << name_ << "] " << symbol << ": $" << price << '\n';
}
private:
std::string name_;
};
class PriceAlert : public StockObserver {
public:
PriceAlert(const std::string& symbol, double threshold)
: symbol_(symbol), threshold_(threshold) {}
void onPriceChanged(const std::string& symbol, double price) override {
if (symbol == symbol_ && price > threshold_) {
std::cout << "ALERT: " << symbol << " exceeded $" << threshold_ << '\n';
}
}
private:
std::string symbol_;
double threshold_;
};
int main() {
StockMarket market;
auto display = std::make_shared<PriceDisplay>("MainDisplay");
auto alert = std::make_shared<PriceAlert>("AAPL", 150.0);
market.attach(display);
market.attach(alert);
market.setPrice("AAPL", 145.0); // [MainDisplay] AAPL: $145
market.setPrice("AAPL", 155.0); // [MainDisplay] AAPL: $155
// ALERT: AAPL exceeded $150
}정리
| 개념 | 설명 |
|---|---|
| Observer Pattern | Subject가 Observer에 상태 변경 알림 |
| 목적 | 느슨한 결합, 이벤트 기반 아키텍처 |
| 구조 | Subject (attach, notify), Observer (update) |
| 장점 | 확장성, 재사용성, 동적 구독 |
| 단점 | 순환 참조, 알림 순서 불확실, 성능 오버헤드 |
| 사용 사례 | UI 업데이트, 이벤트 시스템, MVC 패턴 |
| Observer Pattern은 이벤트 기반 시스템에서 느슨한 결합을 구현하는 핵심 디자인 패턴입니다. |
FAQ
Q1: Observer Pattern은 언제 쓰나요?
A: 한 객체의 상태 변경을 여러 객체에 알려야 하고, 느슨한 결합이 필요할 때 사용합니다.
Q2: weak_ptr을 왜 쓰나요?
A: 순환 참조 방지와 Observer 자동 제거를 위해 사용합니다.
Q3: 알림 순서는 보장되나요?
A: 보장 안 됩니다. 우선순위가 필요하면 우선순위 Observer 패턴을 사용하세요.
Q4: 신호/슬롯과 차이는?
A: 신호/슬롯은 Observer Pattern의 변형으로, 타입 안전하고 함수 객체를 직접 연결합니다 (Qt 스타일).
Q5: 성능 오버헤드는?
A: Observer 수에 비례합니다. 비동기 알림으로 완화 가능합니다.
Q6: Observer Pattern 학습 리소스는?
A:
- “Design Patterns” by Gang of Four
- “Head First Design Patterns” by Freeman & Freeman
- Refactoring Guru: Observer Pattern 한 줄 요약: Observer Pattern으로 이벤트 기반 아키텍처를 구현하고 느슨한 결합을 달성할 수 있습니다. 다음으로 Strategy Pattern을 읽어보면 좋습니다.
같이 보면 좋은 글 (내부 링크)
이 주제와 연결되는 다른 글입니다.