Blog

// mixed.cpp — 구체 클래스를 직접 생성하면 테마가 섞이기 쉽다
#include <iostream>

struct DarkButton    { void draw() const { std::cout << "[Dark ] Button\n"; } };
struct LightButton   { void draw() const { std::cout << "[Light] Button\n"; } };
struct DarkCheckbox  { void draw() const { std::cout << "[Dark ] Checkbox\n"; } };
struct LightCheckbox { void draw() const { std::cout << "[Light] Checkbox\n"; } };

int main()
{
	DarkButton ok;
	LightCheckbox remember;   // 실수: 다크 화면에 라이트 체크박스
	ok.draw();
	remember.draw();
}

// widgets.hpp — 추상 제품과 추상 팩토리
#pragma once
#include <memory>
#include <string>

struct Button {
	virtual ~Button() = default;
	virtual std::string draw() const = 0;
};

struct Checkbox {
	virtual ~Checkbox() = default;
	virtual std::string draw() const = 0;
};

struct WidgetFactory {
	virtual ~WidgetFactory() = default;
	virtual std::unique_ptr<Button>   createButton() const = 0;
	virtual std::unique_ptr<Checkbox> createCheckbox() const = 0;
};

// themes.hpp — 구체 제품과 구체 팩토리 (테마 패밀리 2개)
#pragma once
#include "widgets.hpp"

struct LightButton : Button {
	std::string draw() const override { return "[Light] Button"; }
};
struct LightCheckbox : Checkbox {
	std::string draw() const override { return "[Light] Checkbox"; }
};
struct DarkButton : Button {
	std::string draw() const override { return "[Dark ] Button"; }
};
struct DarkCheckbox : Checkbox {
	std::string draw() const override { return "[Dark ] Checkbox"; }
};

struct LightFactory : WidgetFactory {
	std::unique_ptr<Button>   createButton()   const override { return std::make_unique<LightButton>(); }
	std::unique_ptr<Checkbox> createCheckbox() const override { return std::make_unique<LightCheckbox>(); }
};
struct DarkFactory : WidgetFactory {
	std::unique_ptr<Button>   createButton()   const override { return std::make_unique<DarkButton>(); }
	std::unique_ptr<Checkbox> createCheckbox() const override { return std::make_unique<DarkCheckbox>(); }
};

// basic.cpp — 클라이언트는 추상 팩토리만 안다
#include <iostream>
#include "themes.hpp"

void renderLoginForm(const WidgetFactory &f)
{
	auto ok = f.createButton();
	auto remember = f.createCheckbox();
	std::cout << ok->draw() << '\n' << remember->draw() << '\n';
}

int main()
{
	renderLoginForm(DarkFactory{});
	std::cout << "--\n";
	renderLoginForm(LightFactory{});
}

// registry.cpp — 실행 시점에 테마 이름으로 팩토리를 고른다
#include <functional>
#include <iostream>
#include <map>
#include "themes.hpp"

using FactoryMaker = std::function<std::unique_ptr<WidgetFactory>()>;

const std::map<std::string, FactoryMaker> &registry()
{
	static const std::map<std::string, FactoryMaker> r = {
		{"light", [] { return std::make_unique<LightFactory>(); }},
		{"dark",  [] { return std::make_unique<DarkFactory>(); }},
	};
	return r;
}

int main(int argc, char **argv)
{
	std::string theme = argc > 1 ? argv[1] : "light";
	auto it = registry().find(theme);
	if (it == registry().end()) {
		std::cerr << "unknown theme: " << theme << '\n';
		return 1;
	}
	auto factory = it->second();
	std::cout << factory->createButton()->draw() << '\n'
		  << factory->createCheckbox()->draw() << '\n';
}

// contrast.cpp — 새 패밀리(HighContrast)를 추가해도 renderLoginForm은 그대로다
#include <iostream>
#include "themes.hpp"

struct ContrastButton : Button {
	std::string draw() const override { return "[HiCon] BUTTON"; }
};
struct ContrastCheckbox : Checkbox {
	std::string draw() const override { return "[HiCon] [X] CHECKBOX"; }
};
struct HighContrastFactory : WidgetFactory {
	std::unique_ptr<Button>   createButton()   const override { return std::make_unique<ContrastButton>(); }
	std::unique_ptr<Checkbox> createCheckbox() const override { return std::make_unique<ContrastCheckbox>(); }
};

void renderLoginForm(const WidgetFactory &f)   // basic.cpp와 동일
{
	auto ok = f.createButton();
	auto remember = f.createCheckbox();
	std::cout << ok->draw() << '\n' << remember->draw() << '\n';
}

int main()
{
	renderLoginForm(HighContrastFactory{});
}

// add_product.cpp — 추상 팩토리에 제품(Slider)을 추가하면 모든 구체 팩토리가 영향을 받는다
#include <memory>
#include <string>

struct Slider { virtual ~Slider() = default; virtual std::string draw() const = 0; };
struct DarkSlider : Slider { std::string draw() const override { return "[Dark ] Slider"; } };

struct WidgetFactory {
	virtual ~WidgetFactory() = default;
	virtual std::unique_ptr<Slider> createSlider() const = 0;   // 새로 추가
};
struct DarkFactory : WidgetFactory {
	std::unique_ptr<Slider> createSlider() const override { return std::make_unique<DarkSlider>(); }
};
struct LightFactory : WidgetFactory {
	// createSlider()를 아직 구현하지 않음
};

int main()
{
	DarkFactory dark;
	LightFactory light;   // 여기서 컴파일 에러
	(void)dark; (void)light;
}

// mock.cpp — 테스트에서는 호출을 기록하는 가짜 팩토리를 주입한다
#include <cassert>
#include <iostream>
#include "widgets.hpp"

struct FakeButton : Button { std::string draw() const override { return "btn"; } };
struct FakeCheckbox : Checkbox { std::string draw() const override { return "chk"; } };

struct RecordingFactory : WidgetFactory {
	mutable int buttons = 0, checkboxes = 0;
	std::unique_ptr<Button> createButton() const override
	{ ++buttons; return std::make_unique<FakeButton>(); }
	std::unique_ptr<Checkbox> createCheckbox() const override
	{ ++checkboxes; return std::make_unique<FakeCheckbox>(); }
};

std::string renderLoginForm(const WidgetFactory &f)
{
	return f.createButton()->draw() + "," + f.createCheckbox()->draw();
}

int main()
{
	RecordingFactory f;
	std::string out = renderLoginForm(f);
	assert(out == "btn,chk");
	assert(f.buttons == 1 && f.checkboxes == 1);
	std::cout << "ok: " << out << " (buttons=" << f.buttons
		  << ", checkboxes=" << f.checkboxes << ")\n";
}

// static_factory.cpp — 패밀리를 타입으로 묶어 컴파일 시점에 고르는 추상 팩토리
#include <concepts>
#include <iostream>
#include <string>

struct DarkTheme {
	struct Button   { std::string draw() const { return "[Dark ] Button"; } };
	struct Checkbox { std::string draw() const { return "[Dark ] Checkbox"; } };
};
struct LightTheme {
	struct Button   { std::string draw() const { return "[Light] Button"; } };
	struct Checkbox { std::string draw() const { return "[Light] Checkbox"; } };
};

template <class T>
concept Theme = requires {
	{ typename T::Button{}.draw() }   -> std::convertible_to<std::string>;
	{ typename T::Checkbox{}.draw() } -> std::convertible_to<std::string>;
};

template <Theme T>
void renderLoginForm()
{
	typename T::Button ok;
	typename T::Checkbox remember;
	std::cout << ok.draw() << '\n' << remember.draw() << '\n';
}

struct BrokenTheme { struct Button { std::string draw() const { return ""; } }; };

int main()
{
	renderLoginForm<DarkTheme>();
	renderLoginForm<LightTheme>();
#ifdef SHOW_ERROR
	renderLoginForm<BrokenTheme>();   // Checkbox가 없는 패밀리
#endif
}

/* factory.c — C에서는 함수 포인터 테이블이 추상 팩토리 역할을 한다 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct widget {
	const char *(*draw)(const struct widget *w);
	void (*destroy)(struct widget *w);
};

struct widget_factory {
	const char *name;
	struct widget *(*create_button)(void);
	struct widget *(*create_checkbox)(void);
};

static void widget_free(struct widget *w) { free(w); }

#define DEFINE_WIDGET(fn, text)						\
	static const char *fn##_draw(const struct widget *w)		\
	{ (void)w; return text; }					\
	static struct widget *fn(void)					\
	{								\
		struct widget *w = malloc(sizeof(*w));			\
		if (!w)						\
			abort();					\
		w->draw = fn##_draw;					\
		w->destroy = widget_free;				\
		return w;						\
	}

DEFINE_WIDGET(dark_button,    "[Dark ] Button")
DEFINE_WIDGET(dark_checkbox,  "[Dark ] Checkbox")
DEFINE_WIDGET(light_button,   "[Light] Button")
DEFINE_WIDGET(light_checkbox, "[Light] Checkbox")

static const struct widget_factory factories[] = {
	{ "dark",  dark_button,  dark_checkbox },
	{ "light", light_button, light_checkbox },
};

static void render_login_form(const struct widget_factory *f)
{
	struct widget *ok = f->create_button();
	struct widget *remember = f->create_checkbox();

	printf("%s\n%s\n", ok->draw(ok), remember->draw(remember));
	ok->destroy(ok);
	remember->destroy(remember);
}

int main(int argc, char **argv)
{
	const char *theme = argc > 1 ? argv[1] : "light";

	for (size_t i = 0; i < sizeof(factories) / sizeof(factories[0]); i++) {
		if (strcmp(factories[i].name, theme) == 0) {
			render_login_form(&factories[i]);
			return 0;
		}
	}
	fprintf(stderr, "unknown theme: %s\n", theme);
	return 1;
}