Blog

// sink.hpp — Component와 ConcreteComponent, 그리고 데코레이터 기반 클래스
#pragma once
#include <memory>
#include <string>

struct Sink {                                            // Component
	virtual ~Sink() = default;
	virtual void write(const std::string &data) = 0;
};

struct MemorySink : Sink {                               // ConcreteComponent
	std::string stored;
	void write(const std::string &d) override { stored += d; }
};

class SinkDecorator : public Sink {                      // Decorator
public:
	explicit SinkDecorator(std::unique_ptr<Sink> inner) : inner_(std::move(inner)) {}
protected:
	void forward(const std::string &d) { inner_->write(d); }
private:
	std::unique_ptr<Sink> inner_;
};

// decorators.cpp — 기능을 감싸서 덧붙이고, 순서를 바꿔 쌓아 본다
#include <iostream>
#include "sink.hpp"

struct RleCompress : SinkDecorator {                     // 같은 문자의 연속을 "개수+문자"로
	using SinkDecorator::SinkDecorator;
	void write(const std::string &d) override
	{
		std::string out;
		for (size_t i = 0; i < d.size();) {
			size_t j = i;
			while (j < d.size() && d[j] == d[i] && j - i < 9)
				++j;
			out += char('0' + (j - i));
			out += d[i];
			i = j;
		}
		forward(out);
	}
};

struct XorCipher : SinkDecorator {                       // 데모용 바이트 단위 변환(암호 아님)
	XorCipher(std::unique_ptr<Sink> in, unsigned char key) : SinkDecorator(std::move(in)), key_(key) {}
	void write(const std::string &d) override
	{
		std::string out = d;
		for (size_t i = 0; i < out.size(); ++i)
			out[i] ^= key_ + i;                      // 위치마다 다른 키 → 반복 패턴이 사라짐
		forward(out);
	}
	unsigned char key_;
};

struct Counter : SinkDecorator {                         // 지나가는 바이트 수만 센다
	using SinkDecorator::SinkDecorator;
	void write(const std::string &d) override { bytes += d.size(); forward(d); }
	size_t bytes = 0;
};

int main()
{
	const std::string payload(64, 'A');

	auto m1 = std::make_unique<MemorySink>(); auto *s1 = m1.get();
	RleCompress compressThenCipher(std::make_unique<XorCipher>(std::move(m1), 0x5a));
	compressThenCipher.write(payload);

	auto m2 = std::make_unique<MemorySink>(); auto *s2 = m2.get();
	XorCipher cipherThenCompress(std::make_unique<RleCompress>(std::move(m2)), 0x5a);
	cipherThenCompress.write(payload);

	auto m3 = std::make_unique<MemorySink>(); auto *s3 = m3.get();
	Counter counted(std::move(m3));
	counted.write(payload);

	std::cout << "plain                 : " << s3->stored.size() << " bytes (counter=" << counted.bytes << ")\n"
		  << "compress -> cipher    : " << s1->stored.size() << " bytes\n"
		  << "cipher   -> compress  : " << s2->stored.size() << " bytes\n";
}

// func_deco.cpp — 함수를 감싸는 함수: 재시도·시간 측정 데코레이터
#include <chrono>
#include <functional>
#include <iostream>
#include <stdexcept>
#include <string>
#include <thread>

template <class F>
auto retry(F f, int attempts)
{
	return [f, attempts](auto &&...args) {
		for (int i = 1;; ++i) {
			try {
				return f(args...);
			} catch (const std::exception &e) {
				std::cout << "  attempt " << i << " failed: " << e.what() << '\n';
				if (i == attempts)
					throw;
			}
		}
	};
}

template <class F>
auto timed(std::string name, F f)
{
	return [name, f](auto &&...args) {
		auto t0 = std::chrono::steady_clock::now();
		auto r = f(args...);
		auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::steady_clock::now() - t0).count();
		std::cout << "  " << name << " took ~" << ms << " ms\n";
		return r;
	};
}

int main()
{
	int calls = 0;
	auto flaky = [&calls](int x) {               // 처음 두 번은 실패하는 네트워크 호출 흉내
		std::this_thread::sleep_for(std::chrono::milliseconds(20));
		if (++calls < 3)
			throw std::runtime_error("timeout");
		return x * 2;
	};

	auto robust = timed("fetch", retry(flaky, 5));   // 데코레이터 합성
	int r = robust(21);
	std::cout << "result=" << r << " calls=" << calls << '\n';

	calls = 0;
	try {
		retry(flaky, 2)(1);
	} catch (const std::exception &e) {
		std::cout << "gave up: " << e.what() << '\n';
	}
}

// mixin.cpp — 템플릿 상속으로 컴파일 시점에 쌓는 데코레이터(믹스인)
#include <iostream>
#include <string>

struct ConsoleLog {
	void log(const std::string &m) { std::cout << m << '\n'; }
};

template <class Base>
struct WithLevel : Base {
	void log(const std::string &m) { Base::log("[INFO] " + m); }
};

template <class Base>
struct WithCounter : Base {
	int n = 0;
	void log(const std::string &m) { Base::log("#" + std::to_string(++n) + " " + m); }
};

int main()
{
	WithCounter<WithLevel<ConsoleLog>> a;   // 번호 → 레벨 → 출력
	WithLevel<WithCounter<ConsoleLog>> b;   // 레벨 → 번호 → 출력
	a.log("started"); a.log("ready");
	b.log("started");
	std::cout << "sizeof a=" << sizeof(a) << ", no vtable: "
		  << std::boolalpha << !std::is_polymorphic_v<decltype(a)> << '\n';
}

// identity.cpp — 감싼 객체는 원래 타입이 아니다
#include <iostream>
#include "sink.hpp"

struct Counter : SinkDecorator {
	using SinkDecorator::SinkDecorator;
	void write(const std::string &d) override { bytes += d.size(); forward(d); }
	size_t bytes = 0;
};

int main()
{
	auto mem = std::make_unique<MemorySink>();
	MemorySink *raw = mem.get();
	std::unique_ptr<Sink> s = std::make_unique<Counter>(std::move(mem));
	s->write("hello");

	std::cout << "dynamic_cast<MemorySink*>(decorated) = " << dynamic_cast<MemorySink *>(s.get()) << '\n'
		  << "same address as inner? " << std::boolalpha << (static_cast<void *>(s.get()) == raw) << '\n'
		  << "inner still got the data: " << raw->stored << '\n';
}

/* chain.c — C 데코레이터: 같은 시그니처의 writer를 next로 연결한다 */
#include <ctype.h>
#include <stdio.h>
#include <string.h>

struct writer {
	void (*write)(struct writer *w, const char *s);
	struct writer *next;            /* 감싼 대상 */
	int count;
};

static void stdout_write(struct writer *w, const char *s) { (void)w; fputs(s, stdout); }

static void upper_write(struct writer *w, const char *s)
{
	char buf[256];
	size_t i;
	for (i = 0; s[i] && i < sizeof(buf) - 1; i++)
		buf[i] = (char)toupper((unsigned char)s[i]);
	buf[i] = '\0';
	w->next->write(w->next, buf);
}

static void counting_write(struct writer *w, const char *s)
{
	w->count += (int)strlen(s);
	w->next->write(w->next, s);
}

int main(void)
{
	struct writer out = { stdout_write, NULL, 0 };
	struct writer upper = { upper_write, &out, 0 };
	struct writer counter = { counting_write, &upper, 0 };   /* counter -> upper -> stdout */

	counter.write(&counter, "hello, ");
	counter.write(&counter, "decorator\n");
	printf("counted %d bytes\n", counter.count);
	return 0;
}