Blog

// legacy.hpp — 바꿀 수 없는 외부 라이브러리 (화씨, 정수 1/10도 단위)
#pragma once
class LegacyThermometer {
public:
	explicit LegacyThermometer(int raw) : raw_(raw) {}
	int readFahrenheitTenths() const { return raw_; }   // 986 = 98.6°F
private:
	int raw_;
};

// object_adapter.cpp — 객체 어댑터: 기존 객체를 감싸 새 인터페이스로 노출
#include <iomanip>
#include <iostream>
#include <memory>
#include <vector>
#include "legacy.hpp"

struct TemperatureSensor {                       // 우리 코드가 기대하는 인터페이스
	virtual ~TemperatureSensor() = default;
	virtual double celsius() const = 0;
};

struct DigitalSensor : TemperatureSensor {
	double c;
	explicit DigitalSensor(double v) : c(v) {}
	double celsius() const override { return c; }
};

class ThermometerAdapter : public TemperatureSensor {
public:
	explicit ThermometerAdapter(const LegacyThermometer &t) : t_(t) {}
	double celsius() const override
	{
		double f = t_.readFahrenheitTenths() / 10.0;
		return (f - 32.0) * 5.0 / 9.0;           // 단위 변환이 어댑터의 일
	}
private:
	const LegacyThermometer &t_;
};

int main()
{
	LegacyThermometer old(986);
	std::vector<std::unique_ptr<TemperatureSensor>> sensors;
	sensors.push_back(std::make_unique<DigitalSensor>(36.5));
	sensors.push_back(std::make_unique<ThermometerAdapter>(old));

	for (const auto &s : sensors)
		std::cout << std::fixed << std::setprecision(1) << s->celsius() << " C\n";
}

// class_adapter.cpp — 클래스 어댑터: private 상속으로 구현을 물려받는다
#include <iostream>
#include "legacy.hpp"

struct TemperatureSensor {
	virtual ~TemperatureSensor() = default;
	virtual double celsius() const = 0;
};

class ThermometerClassAdapter : public TemperatureSensor, private LegacyThermometer {
public:
	using LegacyThermometer::LegacyThermometer;            // 생성자 상속
	double celsius() const override
	{ return (readFahrenheitTenths() / 10.0 - 32.0) * 5.0 / 9.0; }
};

int main()
{
	ThermometerClassAdapter a(986);
	const TemperatureSensor &s = a;
	std::cout << s.celsius() << " C, sizeof=" << sizeof(a) << '\n';
#ifdef SHOW_ERROR
	a.readFahrenheitTenths();      // private 상속이라 외부에 노출되지 않는다
#endif
}

// c_callback.cpp — C 콜백 API(void *arg)에 C++ 람다를 끼워 넣는 어댑터
#include <cstdlib>
#include <functional>
#include <iostream>
#include <string>
#include <vector>

// glibc qsort_r: int (*cmp)(const void *, const void *, void *arg)
template <class T, class Cmp>
void sort_with(std::vector<T> &v, Cmp cmp)
{
	auto trampoline = [](const void *a, const void *b, void *arg) -> int {
		auto &f = *static_cast<Cmp *>(arg);                    // arg로 상태를 되찾는다
		const T &x = *static_cast<const T *>(a);
		const T &y = *static_cast<const T *>(b);
		return f(x, y) ? -1 : (f(y, x) ? 1 : 0);
	};
	qsort_r(v.data(), v.size(), sizeof(T), trampoline, &cmp);
}

int main()
{
	std::vector<int> v = {42, 7, 19, 3, 25};
	int calls = 0;                                                     // 캡처할 상태
	sort_with(v, [&calls](int a, int b) { ++calls; return a > b; });   // 내림차순
	for (int x : v)
		std::cout << x << ' ';
	std::cout << "(comparator calls=" << calls << ")\n";
}

// stl_adapters.cpp — 표준 라이브러리 속 어댑터들
#include <algorithm>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <ranges>
#include <stack>
#include <vector>

int main()
{
	// 컨테이너 어댑터: vector/deque에 스택 인터페이스(push/pop/top)만 노출
	std::stack<int, std::vector<int>> s;
	for (int i : {1, 2, 3})
		s.push(i);
	std::cout << "stack top=" << s.top() << " size=" << s.size() << '\n';

	// 반복자 어댑터: push_back을 출력 반복자 인터페이스로
	std::list<int> src = {5, 6, 7};
	std::vector<int> dst;
	std::copy(src.begin(), src.end(), std::back_inserter(dst));
	std::cout << "back_inserter -> " << dst.size() << " elements\n";

	// 범위 어댑터: 역순 + 변환을 원본 수정 없이
	for (int x : dst | std::views::reverse | std::views::transform([](int v) { return v * 10; }))
		std::cout << x << ' ';
	std::cout << '\n';

	// 호출 가능 객체 어댑터: 인자 순서 바꾸기
	auto minus = std::minus<int>{};
	auto rev = [&](int a, int b) { return minus(b, a); };
	std::cout << "minus(10,3)=" << minus(10, 3) << " flipped=" << rev(10, 3) << '\n';
}

/* adapter.c — C: 기존 함수를 새 ops 테이블 인터페이스에 맞추는 어댑터 */
#include <stdio.h>

/* 바꿀 수 없는 레거시 API: 센서 ID로 화씨 1/10도 정수 반환 */
static int legacy_read_f10(int id) { return id == 1 ? 986 : 720; }

/* 새 인터페이스 */
struct sensor {
	const char *name;
	double (*celsius)(const struct sensor *s);
	void *priv;
};

static double digital_celsius(const struct sensor *s) { return *(const double *)s->priv; }

struct legacy_ctx { int id; };
static double legacy_adapter_celsius(const struct sensor *s)
{
	const struct legacy_ctx *ctx = s->priv;
	return (legacy_read_f10(ctx->id) / 10.0 - 32.0) * 5.0 / 9.0;
}

int main(void)
{
	double v = 36.5;
	struct legacy_ctx a = { 1 }, b = { 2 };
	struct sensor sensors[] = {
		{ "digital", digital_celsius, &v },
		{ "legacy#1", legacy_adapter_celsius, &a },
		{ "legacy#2", legacy_adapter_celsius, &b },
	};

	for (size_t i = 0; i < sizeof(sensors) / sizeof(sensors[0]); i++)
		printf("%-9s %.1f C\n", sensors[i].name, sensors[i].celsius(&sensors[i]));
	return 0;
}