Blog

// registry.hpp — 헤더 전용 싱글톤 (함수 내 static)
#pragma once
#include <string>
#include <vector>

class Registry {
public:
	static Registry &instance()
	{
		static Registry r;          // C++11 이후 초기화는 스레드 안전
		return r;
	}
	void add(std::string name) { names_.push_back(std::move(name)); }
	const std::vector<std::string> &names() const { return names_; }
	Registry(const Registry &) = delete;
	Registry &operator=(const Registry &) = delete;
private:
	Registry() = default;
	std::vector<std::string> names_;
};

// basic.cpp — GoF 싱글톤의 최소형: 인스턴스 하나 + 전역 접근점
#include <iostream>
#include "registry.hpp"

int main()
{
	Registry::instance().add("a");
	Registry::instance().add("b");
	std::cout << "same object: " << std::boolalpha
		  << (&Registry::instance() == &Registry::instance())
		  << ", entries=" << Registry::instance().names().size() << '\n';
#ifdef SHOW_ERROR
	Registry copy = Registry::instance();   // 복사 금지
	Registry other;                          // 생성자 private
#endif
}

// subclass.cpp — GoF 변형: 어떤 서브클래스를 단일 인스턴스로 쓸지 첫 호출 때 고른다
#include <cstdlib>
#include <iostream>
#include <memory>
#include <string>

class Logger {
public:
	static Logger &instance()
	{
		static std::unique_ptr<Logger> inst = create();   // 첫 호출에서 한 번만
		return *inst;
	}
	virtual ~Logger() = default;
	virtual void log(const std::string &msg) = 0;
protected:
	Logger() = default;
private:
	static std::unique_ptr<Logger> create();
};

class ConsoleLogger : public Logger {
public:
	void log(const std::string &m) override { std::cout << "[console] " << m << '\n'; }
};
class JsonLogger : public Logger {
public:
	void log(const std::string &m) override { std::cout << "{\"msg\":\"" << m << "\"}\n"; }
};

std::unique_ptr<Logger> Logger::create()
{
	const char *fmt = std::getenv("LOG_FORMAT");
	if (fmt && std::string(fmt) == "json")
		return std::make_unique<JsonLogger>();
	return std::make_unique<ConsoleLogger>();
}

int main()
{
	Logger::instance().log("started");
	Logger::instance().log("ready");
}

// plugin_a.cpp — 공유 라이브러리 A가 싱글톤에 등록한다
#include "registry.hpp"
extern "C" __attribute__((visibility("default"))) void plugin_a_init()
{
	Registry::instance().add("plugin_a");
}
extern "C" __attribute__((visibility("default"))) const void *plugin_a_registry()
{
	return &Registry::instance();
}

// app.cpp — 두 라이브러리를 링크한 실행 파일에서 싱글톤 개수를 확인한다
#include <iostream>
#include "registry.hpp"

extern "C" void plugin_a_init();
extern "C" void plugin_b_init();
extern "C" const void *plugin_a_registry();
extern "C" const void *plugin_b_registry();

int main()
{
	plugin_a_init();
	plugin_b_init();
	Registry::instance().add("app");

	std::cout << "app  : " << &Registry::instance() << '\n'
		  << "lib a: " << plugin_a_registry() << '\n'
		  << "lib b: " << plugin_b_registry() << '\n'
		  << "app sees " << Registry::instance().names().size() << " entries:";
	for (const auto &n : Registry::instance().names())
		std::cout << ' ' << n;
	std::cout << '\n';
}

#!/bin/bash
# build.sh <default|hidden> — 같은 소스를 심볼 가시성만 바꿔 빌드한다
set -e
vis=$1
flags="-std=c++20 -O2 -fPIC"
[ "$vis" = hidden ] && flags="$flags -fvisibility=hidden -fvisibility-inlines-hidden"
g++ $flags -shared -o libplugin_a.so plugin_a.cpp
g++ $flags -shared -o libplugin_b.so plugin_b.cpp
g++ -std=c++20 -O2 -o app app.cpp -L. -lplugin_a -lplugin_b -Wl,-rpath,'$ORIGIN'

// monostate.cpp — 모노스테이트: 객체는 여러 개, 상태는 하나
#include <iostream>
#include <string>

class Config {
public:
	void set(const std::string &k, int v) { if (k == "workers") workers_ = v; }
	int workers() const { return workers_; }
private:
	inline static int workers_ = 4;    // 모든 인스턴스가 공유
};

void configure() { Config c; c.set("workers", 16); }
int  readWorkers() { Config c; return c.workers(); }

int main()
{
	std::cout << "before: " << readWorkers() << '\n';
	configure();
	std::cout << "after : " << readWorkers() << '\n';
}

/* once.c — C 싱글톤: 파일 static + 접근 함수 + pthread_once 지연 초기화 */
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>

struct config {
	int workers;
	const char *log_dir;
};

static struct config *g_config;                    /* 이 파일 밖에서는 보이지 않는다 */
static pthread_once_t g_once = PTHREAD_ONCE_INIT;
static int g_init_calls;

static void config_init(void)
{
	g_config = malloc(sizeof(*g_config));
	if (!g_config)
		abort();
	g_config->workers = 4;
	g_config->log_dir = "/var/log/app";
	g_init_calls++;
}

const struct config *config_get(void)
{
	pthread_once(&g_once, config_init);
	return g_config;
}

static void *reader(void *arg)
{
	*(const struct config **)arg = config_get();
	return NULL;
}

int main(void)
{
	pthread_t t[8];
	const struct config *seen[8];

	for (int i = 0; i < 8; i++)
		pthread_create(&t[i], NULL, reader, &seen[i]);
	for (int i = 0; i < 8; i++)
		pthread_join(t[i], NULL);

	int same = 1;
	for (int i = 1; i < 8; i++)
		same &= seen[i] == seen[0];
	printf("threads=8 init_calls=%d same_instance=%d workers=%d\n",
	       g_init_calls, same, config_get()->workers);
	free(g_config);
	return 0;
}