Blog

// explosion.cpp — 도형 × 렌더러를 상속으로 조합하면 클래스가 곱으로 늘어난다
#include <iostream>

struct Shape { virtual ~Shape() = default; virtual void draw() const = 0; };
struct Circle : Shape {};
struct Rect : Shape {};
struct SvgCircle   : Circle { void draw() const override { std::cout << "<circle r=\"5\"/>\n"; } };
struct AsciiCircle : Circle { void draw() const override { std::cout << "( o )\n"; } };
struct SvgRect     : Rect   { void draw() const override { std::cout << "<rect w=\"4\" h=\"2\"/>\n"; } };
struct AsciiRect   : Rect   { void draw() const override { std::cout << "[____]\n"; } };
// 렌더러 하나(Canvas)를 추가하면 CanvasCircle, CanvasRect ... 도형 수만큼 또 늘어난다

int main()
{
	SvgCircle{}.draw();
	AsciiRect{}.draw();
}

// bridge.cpp — 추상(Shape)과 구현(Renderer)을 두 계층으로 나누고 참조로 잇는다
#include <iostream>
#include <memory>
#include <string>

struct Renderer {                                   // Implementor
	virtual ~Renderer() = default;
	virtual void circle(double r) = 0;
	virtual void rect(double w, double h) = 0;
};
struct SvgRenderer : Renderer {
	void circle(double r) override { std::cout << "<circle r=\"" << r << "\"/>\n"; }
	void rect(double w, double h) override { std::cout << "<rect w=\"" << w << "\" h=\"" << h << "\"/>\n"; }
};
struct AsciiRenderer : Renderer {
	void circle(double r) override { std::cout << "(" << std::string(int(r), 'o') << ")\n"; }
	void rect(double w, double) override { std::cout << "[" << std::string(int(w), '_') << "]\n"; }
};

class Shape {                                       // Abstraction
public:
	explicit Shape(Renderer &r) : r_(&r) {}
	virtual ~Shape() = default;
	virtual void draw() const = 0;
	virtual void scale(double f) = 0;
	void setRenderer(Renderer &r) { r_ = &r; }     // 구현을 실행 중에 교체
protected:
	Renderer *r_;
};
class Circle : public Shape {                       // RefinedAbstraction
public:
	Circle(Renderer &r, double rad) : Shape(r), rad_(rad) {}
	void draw() const override { r_->circle(rad_); }
	void scale(double f) override { rad_ *= f; }
private:
	double rad_;
};
class Rect : public Shape {
public:
	Rect(Renderer &r, double w, double h) : Shape(r), w_(w), h_(h) {}
	void draw() const override { r_->rect(w_, h_); }
	void scale(double f) override { w_ *= f; h_ *= f; }
private:
	double w_, h_;
};

int main()
{
	SvgRenderer svg;
	AsciiRenderer ascii;
	Circle c(svg, 3);
	Rect r(ascii, 4, 2);
	c.draw();
	r.draw();

	c.scale(2);              // 추상 쪽 변경
	c.setRenderer(ascii);    // 구현 쪽 변경 — 서로 독립
	c.draw();
}

// widget.hpp — 공개 헤더: 구현 세부가 전혀 없다
#pragma once
#include <memory>
#include <string>

class Widget {
public:
	explicit Widget(std::string name);
	~Widget();                                   // Impl이 완전한 타입인 .cpp에서 정의
	Widget(Widget &&) noexcept;
	Widget &operator=(Widget &&) noexcept;
	std::string render() const;
private:
	struct Impl;                                 // 전방 선언만
	std::unique_ptr<Impl> impl_;
};

// widget_v1.cpp — 구현 1
#include "widget.hpp"

struct Widget::Impl {
	std::string name;
	std::string render() const { return "v1:" + name; }
};

Widget::Widget(std::string name) : impl_(std::make_unique<Impl>(Impl{std::move(name)})) {}
Widget::~Widget() = default;
Widget::Widget(Widget &&) noexcept = default;
Widget &Widget::operator=(Widget &&) noexcept = default;
std::string Widget::render() const { return impl_->render(); }

// client.cpp — 헤더만 보고 컴파일된다
#include <iostream>
#include "widget.hpp"

int main()
{
	Widget w("button");
	std::cout << w.render() << '\n' << w.render() << '\n'
		  << "sizeof(Widget)=" << sizeof(Widget) << '\n';
}

// widget_v2.cpp — 구현 2: 멤버가 늘고 내부 구조가 바뀌었다
#include <vector>
#include "widget.hpp"

struct Widget::Impl {
	std::string name;
	std::vector<std::string> cache;              // 새 멤버
	int renders = 0;
	std::string render()
	{
		++renders;
		cache.push_back(name);
		return "v2:" + name + " (#" + std::to_string(renders) + ")";
	}
};

Widget::Widget(std::string name) : impl_(std::make_unique<Impl>(Impl{std::move(name), {}, 0})) {}
Widget::~Widget() = default;
Widget::Widget(Widget &&) noexcept = default;
Widget &Widget::operator=(Widget &&) noexcept = default;
std::string Widget::render() const { return impl_->render(); }

// widget_bad.hpp — 소멸자를 선언하지 않으면 컴파일러가 헤더에서 암묵적으로 만든다
#pragma once
#include <memory>

class WidgetBad {
public:
	WidgetBad();
private:
	struct Impl;
	std::unique_ptr<Impl> impl_;
};

/* storage.h — 공개 API: 구조체 정의가 없는 불투명 핸들 */
#ifndef STORAGE_H
#define STORAGE_H
#include <stddef.h>

struct storage;                                  /* 불투명 타입 */

struct storage *storage_open_memory(void);
struct storage *storage_open_file(const char *path);
int  storage_put(struct storage *s, const char *key, const char *val);
const char *storage_backend(const struct storage *s);
void storage_close(struct storage *s);
#endif

/* storage.c — 추상(storage)과 구현(backend ops)을 분리한 C 브리지 */
#include <stdio.h>
#include <stdlib.h>
#include "storage.h"

struct backend_ops {                             /* Implementor */
	const char *name;
	int  (*put)(void *ctx, const char *k, const char *v);
	void (*close)(void *ctx);
};

struct storage {                                 /* Abstraction: 사용자는 내부를 모른다 */
	const struct backend_ops *ops;
	void *ctx;
	int puts;
};

static int mem_put(void *ctx, const char *k, const char *v)
{
	(void)ctx;
	printf("  mem: %s=%s\n", k, v);
	return 0;
}
static void mem_close(void *ctx) { (void)ctx; }
static const struct backend_ops mem_ops = { "memory", mem_put, mem_close };

static int file_put(void *ctx, const char *k, const char *v)
{
	return fprintf(ctx, "%s=%s\n", k, v) < 0 ? -1 : 0;
}
static void file_close(void *ctx) { fclose(ctx); }
static const struct backend_ops file_ops = { "file", file_put, file_close };

static struct storage *storage_new(const struct backend_ops *ops, void *ctx)
{
	struct storage *s = calloc(1, sizeof(*s));
	if (!s)
		return NULL;
	s->ops = ops;
	s->ctx = ctx;
	return s;
}

struct storage *storage_open_memory(void) { return storage_new(&mem_ops, NULL); }
struct storage *storage_open_file(const char *path)
{
	FILE *f = fopen(path, "w");
	return f ? storage_new(&file_ops, f) : NULL;
}
int storage_put(struct storage *s, const char *k, const char *v)
{
	s->puts++;                                   /* 공통 로직은 추상 쪽에 */
	return s->ops->put(s->ctx, k, v);
}
const char *storage_backend(const struct storage *s) { return s->ops->name; }
void storage_close(struct storage *s)
{
	printf("  close %s after %d puts\n", s->ops->name, s->puts);
	s->ops->close(s->ctx);
	free(s);
}

/* main.c — storage.h만 안다 */
#include <stdio.h>
#include "storage.h"

static void save(struct storage *s)
{
	printf("[%s]\n", storage_backend(s));
	storage_put(s, "user", "kim");
	storage_put(s, "lang", "ko");
	storage_close(s);
}

int main(void)
{
	struct storage *m = storage_open_memory();
	struct storage *f = storage_open_file("out.txt");

	if (!m || !f)
		return 1;
	save(m);
	save(f);
	return 0;
}

/* peek.c — 불투명 타입의 내부에 접근하려 하면 */
#include "storage.h"
int peek(struct storage *s) { return s->puts; }