Blog

// importer.cpp — 알고리즘 뼈대(run)는 부모가, 단계는 자식이. 필수 단계와 선택적 훅
#include <iostream>
#include <sstream>
#include <string>
#include <vector>

struct Record { std::string name; int score; };

class Importer {
public:
	virtual ~Importer() = default;
	int run(const std::string &raw)                         // 템플릿 메서드: 순서는 고정
	{
		auto rows = parse(raw);                             // 필수 단계
		std::vector<Record> kept;
		for (const auto &r : rows)
			if (accept(r))                                  // 훅: 기본은 전부 통과
				kept.push_back(r);
		save(kept);                                         // 필수 단계
		afterSave(kept.size());                             // 훅: 기본은 아무것도 안 함
		return static_cast<int>(kept.size());
	}
protected:
	virtual std::vector<Record> parse(const std::string &raw) = 0;
	virtual void save(const std::vector<Record> &rows) = 0;
	virtual bool accept(const Record &) { return true; }
	virtual void afterSave(std::size_t) {}
};

class CsvImporter : public Importer {
protected:
	std::vector<Record> parse(const std::string &raw) override
	{
		std::vector<Record> out;
		std::istringstream in(raw);
		for (std::string line; std::getline(in, line);) {
			auto c = line.find(',');
			out.push_back({line.substr(0, c), std::stoi(line.substr(c + 1))});
		}
		return out;
	}
	void save(const std::vector<Record> &rows) override
	{ for (auto &r : rows) std::cout << "  INSERT " << r.name << ' ' << r.score << '\n'; }
};

class PassingOnlyCsv : public CsvImporter {                  // 훅만 재정의
protected:
	bool accept(const Record &r) override { return r.score >= 60; }
	void afterSave(std::size_t n) override { std::cout << "  notify: " << n << " rows imported\n"; }
};

int main()
{
	const std::string data = "kim,90\nlee,45\npark,72\n";
	std::cout << "CsvImporter:\n";
	CsvImporter a;
	a.run(data);
	std::cout << "PassingOnlyCsv:\n";
	PassingOnlyCsv b;
	b.run(data);
}

// call_super.cpp — "재정의할 때 부모 것도 꼭 불러라" 규칙은 잊히기 쉽다. NVI로 강제한다
#include <iostream>
#include <mutex>
#include <string>

namespace call_super {                          // 안티패턴
class Service {
public:
	virtual ~Service() = default;
	virtual void start() { std::cout << "    base: open log, register metrics\n"; started = true; }
	bool started = false;
};
struct Good : Service {
	void start() override { Service::start(); std::cout << "    good: bind port\n"; }
};
struct Forgetful : Service {
	void start() override { std::cout << "    forgetful: bind port\n"; }   // Service::start() 누락
};
}

namespace nvi {                                 // Non-Virtual Interface
class Service {
public:
	virtual ~Service() = default;
	void start()                                // 비가상 공개 함수: 순서를 부모가 쥔다
	{
		std::lock_guard lk(m_);
		std::cout << "    base: open log, register metrics\n";
		doStart();                              // 자식이 채우는 단계
		started = true;
		std::cout << "    base: started\n";
	}
	bool started = false;
private:
	virtual void doStart() = 0;                 // private 가상: 재정의만 가능, 직접 호출 불가
	std::mutex m_;
};
struct Http : Service {
private:
	void doStart() override { std::cout << "    http: bind port\n"; }
};
}

int main()
{
	std::cout << std::boolalpha << "call-super:\n";
	call_super::Good g;      g.start(); std::cout << "  good.started=" << g.started << '\n';
	call_super::Forgetful f; f.start(); std::cout << "  forgetful.started=" << f.started << '\n';

	std::cout << "NVI:\n";
	nvi::Http h; h.start(); std::cout << "  http.started=" << h.started << '\n';
#ifdef SHOW_ERROR
	h.doStart();                                // 사전·사후 처리를 건너뛰는 직접 호출
#endif
}

// crtp_tm.cpp — 가상 함수 없는 템플릿 메서드(CRTP): 단계가 없으면 컴파일 에러
#include <iostream>
#include <string>

template <class Derived>
class Report {
public:
	std::string render()                                   // 뼈대
	{
		auto &d = static_cast<Derived &>(*this);
		return d.header() + d.body() + footer();
	}
private:
	std::string footer() { return "-- end --\n"; }
};

struct Daily : Report<Daily> {
	std::string header() { return "[daily]\n"; }
	std::string body() { return "  42 jobs ok\n"; }
};
struct Weekly : Report<Weekly> {
	std::string header() { return "[weekly]\n"; }
	std::string body() { return "  290 jobs ok, 3 failed\n"; }
};
#ifdef SHOW_ERROR
struct Broken : Report<Broken> {
	std::string header() { return "[broken]\n"; }          // body() 누락
};
#endif

int main()
{
	std::cout << Daily{}.render() << Weekly{}.render();
#ifdef SHOW_ERROR
	std::cout << Broken{}.render();
#endif
}

/* runner.c — C 템플릿 메서드: 실행 순서(setup → run → teardown)는 러너가, 단계는 테스트가 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

struct test_case {
	const char *name;
	void *(*setup)(void);               /* 선택: NULL이면 생략(훅) */
	int  (*run)(void *fixture);         /* 필수: 0이면 성공 */
	void (*teardown)(void *fixture);    /* 선택 */
};

static int run_all(const struct test_case *tc, size_t n)    /* 템플릿 메서드 */
{
	int failed = 0;

	for (size_t i = 0; i < n; i++) {
		void *fx = tc[i].setup ? tc[i].setup() : NULL;
		int rc = tc[i].run(fx);
		if (tc[i].teardown)
			tc[i].teardown(fx);         /* 실패해도 정리는 항상 */
		printf("[%s] %s\n", rc == 0 ? " OK " : "FAIL", tc[i].name);
		failed += rc != 0;
	}
	printf("%zu tests, %d failed\n", n, failed);
	return failed;
}

static void *buf_setup(void) { char *b = malloc(32); if (b) strcpy(b, "hello"); return b; }
static void buf_teardown(void *fx) { free(fx); }
static int test_len(void *fx) { return strlen(fx) == 5 ? 0 : 1; }
static int test_upper(void *fx) { return ((char *)fx)[0] == 'H' ? 0 : 1; }   /* 일부러 실패 */
static int test_math(void *fx) { (void)fx; return 2 + 2 == 4 ? 0 : 1; }

int main(void)
{
	const struct test_case tests[] = {
		{ "buffer length", buf_setup, test_len, buf_teardown },
		{ "buffer upper",  buf_setup, test_upper, buf_teardown },
		{ "arithmetic",    NULL,      test_math, NULL },
	};
	return run_all(tests, sizeof(tests) / sizeof(tests[0])) ? 1 : 0;
}