C++ 이디엄
Cpp 관용구
· 마지막 업데이트: 2026-11-07 · 18 min read
개요
C++ 이디엄이 특히 중요한 이유는 언어가 raw pointer, manual memory, 예외, 다중 상속, 템플릿 메타프로그래밍을 모두 허용하기 때문이다. 컴파일러가 강제하지 않는 불변조건(invariant)을 코드 형태로 인코딩하는 커뮤니티 관례가 사실상 안전 경계 역할을 한다. Rust의 borrow checker처럼 도구가 강제하는 게 아니라 사람이 유지해야 한다는 점이 핵심이다.
여기서 이디엄은 C++의 여러 기능을 반복해서 쓰는 코드 형태로 묶은 관례를 뜻한다. 예를 들어 메모리를 할당할 수 있다는 언어 기능만으로는 누가 언제 해제할지가 정해지지 않으므로, 소유 객체의 수명에 해제를 묶거나 소유권을 포인터 타입으로 드러내는 방식까지 함께 정한다.
아래 항목은 이름보다 해결하는 문제를 먼저 보면 읽기 쉽다. 자원을 돌려주는 시점을 다루는 RAII에서 시작해, 복사와 이동을 누가 맡는지, 구현을 어디에 숨기는지, 여러 타입을 어떻게 표현하는지로 이어진다. 같은 자원 관리라도 ‘해제를 언제 하는가’와 ‘해제할 책임이 누구에게 있는가’는 다른 질문이어서 RAII와 스마트 포인터 소유권을 나누어 설명한다.
개인적인 메모: 저수준 제어를 중시하는 중국같은 생태계에서는 C++ 위주로 돌아가는 경향이 있다.
1. 리소스 관리
RAII (Resource Acquisition Is Initialization)
리소스 획득을 객체 수명에 묶는 이디엄. 생성자에서 획득, 소멸자에서 해제. C++ 안전성의 토대.1
해결하는 문제: 예외, early return, break 등 어떤 경로로 스코프를 빠져나가도 리소스가 누수되지 않는다. C의 goto cleanup 패턴을 컴파일러가 자동으로 처리해주는 셈.
{
std::lock_guard<std::mutex> lock(mtx); // 획득
// 예외가 던져져도, return 해도, 정상 종료해도
// 스코프 종료 시점에 lock이 자동 해제
}
대표 예시: std::lock_guard, std::unique_ptr, std::fstream, std::scoped_lock.
앞의 잠금 예제에서는 lock_guard 생성자가 mtx를 잠그고, 지역 변수 lock이 중괄호 안에서 그 잠금을 맡는다. 실행이 블록을 벗어나며 이 변수가 소멸할 때 소멸자가 잠금을 푼다. 잠금과 해제를 객체의 생성·소멸에 묶었으므로, 블록 안의 각 반환 경로마다 해제 호출을 따로 적는 일을 줄인다.2
Rule of Zero / Three / Five
리소스를 소유하는 클래스의 special member function(소멸자, 복사 생성자, 복사 대입, 이동 생성자, 이동 대입)을 어떻게 다룰지에 대한 메타 이디엄. ACCU의 2014년 글은 Rule of Three라는 이름을 Marshall Cline의 1991년 명명으로 추적한다. C++11에서 이동 연산이 추가되며 Rule of Five로 확장되었다.3
Rule of Zero (가장 권장): 직접 special member function을 작성하지 말고 RAII 컴포넌트에 위임. 컴파일러 생성 버전이 알아서 한다.
Rule of Three (C++98): 소멸자, 복사 생성자, 복사 대입 중 하나를 정의했다면 셋 다 정의해야 한다.
Rule of Five (C++11): 위 셋에 이동 생성자, 이동 대입 연산자까지 다섯 개를 함께 고려.
해결하는 문제: 리소스 소유 클래스가 복사/이동될 때 이중 해제, 누수, 부분 상태 발생.
// Rule of Zero - 권장
class Buffer
{
std::vector<int> data; // vector가 알아서 복사/이동/소멸 처리
std::string name;
// special member 함수 작성 안 함
};
// Rule of Five - 직접 OS 리소스를 잡을 때만
class FileHandle
{
public:
explicit FileHandle(const char* path);
~FileHandle(); // (1)
FileHandle(const FileHandle&) = delete; // (2) 복사 금지
FileHandle& operator=(const FileHandle&) = delete; // (3)
FileHandle(FileHandle&&) noexcept; // (4)
FileHandle& operator=(FileHandle&&) noexcept; // (5)
private:
int fd;
};
Smart pointer ownership
소유권을 type으로 표현. raw pointer는 기본적으로 non-owning 관찰자로 사용한다.4
std::unique_ptr<T>: 단일 소유. 이동만 가능, 복사 불가. 비용 거의 0.std::shared_ptr<T>: 공유 소유. control block의 참조 카운트로 마지막 소유자가 사라질 때 해제한다. 복사/소멸 시 참조 카운트 조작에 동기화 비용이 발생한다. 카운트만 atomic이지 가리키는 객체 자체가 thread-safe해지는 건 아니다.std::weak_ptr<T>:shared_ptr의 비소유 관찰자. lifetime을 연장하지 않는다 (strong count 안 늘림). 다만 control block은 weak count가 0이 될 때까지 해제되지 않으므로 완전한 무비용은 아니다. 순환 참조 끊기 용도.
해결하는 문제: "이 포인터를 누가 delete 해야 하는가"라는 ownership 모호성. raw pointer는 함수 시그니처만 봐서는 소유인지 관찰인지 알 수 없다.
auto conn = std::make_unique<Connection>(host, port); // 단일 소유
auto cfg = std::make_shared<Config>(); // 공유 소유
std::weak_ptr<Config> watcher = cfg; // 관찰만, strong count 증가 없음
void use(Connection* c); // non-owning 인자 — 애플리케이션 코드에서 raw pointer의 가장 일반적인 정당한 용법
use(conn.get());
선택 순서: unique_ptr → 공유 의미가 진짜 필요할 때만 shared_ptr → non-owning 참조는 raw pointer 또는 T&.
예제의 conn.get()은 Connection을 새로 만들거나 소유권을 넘기지 않고, conn이 관리하는 객체의 주소를 use에 전달한다. 이 코드에서 수명을 맡은 쪽은 계속 conn이다. 함수를 부를 때 객체를 잠깐 사용하는 관계와, 나중에 객체를 해제할 책임을 갖는 관계를 구별하려고 포인터 타입과 호출 형태를 함께 읽는다.
raw pointer를 non-owning view로 쓰는 게 원칙이라는 건 애플리케이션 코드 기준이다. 다음 경계에서는 raw pointer가 소유나 그 외 용도로 정당하게 쓰인다:
C API boundary (
malloc/free, OS handle)arena/pool allocator 내부
intrusive data structure
placement new
레거시 ABI 호환
allocation-free 임베디드/실시간 영역
개인적인 메모: 현장에서는 RAII와 소유권 모델보다 raw pointer 신앙이 더 강하다.
C++의 난이도는 문법이 아니라 사람에게서 온다.
copy-and-swap
복사 대입 연산자를 "값 전달로 복사본을 받고 swap"으로 구현하는 이디엄. Herb Sutter의 Guru of the Week #59(1999)는 이 방식의 예제를 설명한다.5
해결하는 문제: 예외 안전성 + 자기 대입(a = a) 처리를 한 번에. 대입 도중 예외가 나도 객체가 부분 상태로 깨지지 않는다. 새 복사본 생성이 실패하면 원본은 그대로 유지된다.
// vector, string 같은 RAII 멤버만 사용하면 Rule of Zero로 충분하다.
// 아래는 copy-and-swap을 보여 주려고 복사·이동 생성자를 명시한 예제다.
class Resource
{
public:
Resource() = default;
Resource(const Resource&) = default;
Resource(Resource&&) noexcept = default; // by-value operator=만 두면 암시적으로 선언되지 않는다
Resource& operator=(Resource other) // ← by value
{
swap(*this, other);
return *this;
}
friend void swap(Resource& a, Resource& b) noexcept
{
using std::swap;
swap(a.data, b.data);
swap(a.name, b.name);
}
private:
std::vector<int> data;
std::string name;
};
트레이드오프: copy-and-swap은 강한 예외 안전성을 보장하지만 대입받을 값을 별도 매개변수 객체로 준비하므로 기존 저장소를 재사용하기 어렵다. C++11 이후 by-value assignment 하나로 복사 대입과 이동 대입을 어느 정도 통합할 수는 있다 — rvalue가 들어오면 move constructor가 other를 만들기 때문이다. by-value operator=는 사용자 선언 복사 대입 연산자로 취급되어 이동 생성자의 암시적 생성을 막는다. 그래서 위 예제는 이동 생성자를 직접 선언하고, 그 때문에 암시적으로 생성되지 않는 기본 생성자와 삭제될 수 있는 복사 생성자도 함께 명시했다. 또 성능에 민감한 컨테이너/버퍼 타입은 복사 대입과 이동 대입을 별도로 구현하고, 이동 대입은 swap만 수행하는 편이 효율적이다.
2. 캡슐화와 인터페이스 설계
Pimpl (Pointer to Implementation)
클래스 본체에는 구현 세부사항을 forward 선언된 포인터로만 두고, 실제 구현은 .cpp에 정의. "Cheshire Cat" 또는 "compilation firewall"이라고도 부른다. Herb Sutter의 GotW #24와 C++11 갱신판 GotW #100/#101이 가장 자주 인용되는 출처다.6
해결하는 문제: 헤더 변경으로 인한 재컴파일 전파 차단, ABI 안정성, 사설 의존 헤더의 클라이언트 노출 방지.
// widget.h
class Widget
{
public:
Widget();
~Widget();
void draw();
Widget(Widget&&) noexcept;
Widget& operator=(Widget&&) noexcept;
private:
struct Impl; // forward 선언만
std::unique_ptr<Impl> impl;
};
// widget.cpp
struct Widget::Impl
{
Renderer renderer; // 실제 멤버
State state;
};
Widget::Widget() : impl(std::make_unique<Impl>()) {}
Widget::~Widget() = default; // Impl 완전 정의 시점에 정의
비용: 동적 할당 한 번, 간접 호출 한 번. 핫 경로엔 부적합.
주의 1: 소멸자, 이동 연산을 헤더에 = default로 두면 안 된다 — Impl이 incomplete type인 시점에 unique_ptr이 인스턴스화되면서 에러. .cpp에서 정의해야 한다. 흔히 놓치는 함정이라 별표.
주의 2: std::unique_ptr<Impl>을 멤버로 두면 컴파일러가 생성하는 복사 생성자/복사 대입은 자동으로 삭제된다(unique_ptr이 복사 불가). Pimpl 객체가 복사 가능해야 한다면 복사 생성자와 복사 대입을 직접 정의하여 Impl을 deep copy해야 한다.
NVI (Non-Virtual Interface)
public 인터페이스는 non-virtual, 실제 다형성은 private virtual로 구현하는 이디엄. Herb Sutter는 2001년 C/C++ Users Journal의 "Virtuality" 글에서 public non-virtual 인터페이스와 내부 virtual 동작을 나누는 구성을 권장했다.7
해결하는 문제: 인터페이스와 동작 분리. 기반 클래스가 사전/사후 조건, 인자 검증, 로깅 같은 횡단 관심사를 강제할 수 있다. 파생 클래스는 동작만 구현.
class Document
{
public:
virtual ~Document() = default; // Document*를 통한 파생 객체 삭제를 허용한다
void save() // public non-virtual
{
validate();
do_save(); // 다형성 지점
log_saved();
}
private:
virtual void do_save() = 0; // 파생 클래스가 구현할 부분
void validate() const;
void log_saved() const;
};
파생 객체를 기반 클래스 포인터로 삭제하게 설계했다면 기반 클래스에 public virtual destructor를 둔다. 가상 소멸자 없는 기반 포인터로 수행한 delete base_ptr는 정의되지 않은 동작이다. 흔히 파생 클래스의 소멸자가 호출되지 않는 형태로 드러난다.
3. 타입 수준 표현
std::optional로 부재 표현
값이 있을 수도 없을 수도 있는 경우 nullptr이나 sentinel value(-1, 빈 문자열 등) 대신 std::optional<T>를 사용.8
해결하는 문제: nullptr dereference, "음수면 실패" 같은 ad-hoc 컨벤션, 함수 시그니처가 실패 가능성을 숨기는 문제.
std::optional<User> find_user(UserId id)
{
if (auto record = db.lookup(id)) {
return User(*record);
}
return std::nullopt;
}
if (auto user = find_user(id)) {
process(*user); // 안에서 *user 또는 user->method()
}
트레이드오프: 실패 이유가 여러 개라면 std::expected<T, E> (C++23) 또는 Result 계열 타입이 더 적절. optional은 "있다/없다" 두 상태만.
주의: std::optional<T&>는 C++23까지 표준에 없고, C++26에 채택되었다(P2988). C++23 이하에서는 참조에 std::optional<std::reference_wrapper<T>> 또는 raw pointer T*를 쓴다.
std::variant + std::visit로 합 타입 표현
여러 타입 중 하나를 담는 type-safe union. std::visit으로 패턴 매칭에 가까운 dispatch.9
해결하는 문제: 상속 계층 없이 닫힌 타입 집합을 표현. dynamic_cast 회피. overload set을 쓰면 컴파일러가 모든 alternative에 대해 처리 가능성을 검증할 수 있다.
using Shape = std::variant<Circle, Square, Triangle>;
double area(const Shape& s)
{
return std::visit([](const auto& shape) {
return shape.area(); // 모든 타입에 area()가 있어야 함
}, s);
}
// overload set으로 타입별 처리
template<class... Ts>
struct Overloaded : Ts...
{
using Ts::operator()...;
};
template<class... Ts>
Overloaded(Ts...) -> Overloaded<Ts...>;
double area2(const Shape& s)
{
return std::visit(Overloaded {
[](const Circle& c) { return 3.14 * c.r * c.r; },
[](const Square& q) { return q.side * q.side; },
[](const Triangle& t) { return 0.5 * t.base * t.height; }
}, s);
}
exhaustiveness에 관한 주의: 위 두 예시는 강제 수준이 다르다.
area의 generic lambda는 "모든 alternative가area()를 호출 가능해야 한다"는 것만 강제한다. 타입별 명시적 처리는 강제하지 않는다.area2의 overload set은 alternative마다 매칭되는 오버로드가 있어야 컴파일이 통과한다. 닫힌 타입 집합에 대해 누락된 케이스를 컴파일 타임에 드러낼 수 있다. 단, generic lambda(auto)나 catch-all 오버로드를 섞으면 exhaustiveness가 약해진다.
트레이드오프: 컴파일 시간 증가. 타입 집합이 자주 확장되는 도메인이라면 virtual function 계층이 더 유연.
4. 템플릿과 컴파일 타임 이디엄
CRTP (Curiously Recurring Template Pattern)
파생 클래스가 자기 자신을 템플릿 인자로 기반 클래스에 전달하는 패턴. James Coplien이 1995년 C++ Report에서 초기 C++ 템플릿 코드의 반복 패턴을 관찰하고 명명했다.10 정적 다형성, mixin, 정책 주입에 사용.
해결하는 문제: virtual function의 런타임 비용(vtable lookup) 없이 인터페이스 재사용. 정적 분기. 그리고 기반 클래스가 파생 클래스에 코드를 "주입"하는 mixin 효과.
template<typename Derived>
class Comparable
{
public:
bool operator!=(const Derived& other) const
{
return !static_cast<const Derived&>(*this).operator==(other);
}
bool operator<=(const Derived& other) const
{
const auto& self = static_cast<const Derived&>(*this);
return self < other || self == other;
}
};
class Point : public Comparable<Point>
{
public:
bool operator==(const Point& o) const { return x == o.x && y == o.y; }
bool operator<(const Point& o) const { return x < o.x || (x == o.x && y < o.y); }
private:
int x, y;
};
비용: 인터페이스가 컴파일 타임에 고정. 런타임에 타입을 바꿔야 하는 다형성에는 부적합. 코드 비대 가능성.
C++20 concepts와의 관계: CRTP가 인터페이스 conformance를 체크하는 용도(파생 타입이 특정 연산을 제공한다는 사실의 표현)로 쓰였다면 concepts가 훨씬 깔끔하게 대체한다. 다만 위 Comparable<Point> 예시처럼 기반 클래스가 파생 클래스에 메서드를 주입하는 mixin 용도는 concepts로 대체되지 않는다. 이 부분은 여전히 CRTP 또는 다른 합성 기법이 필요하다.
Type erasure
구체 타입을 숨기고 인터페이스만 노출하는 이디엄. 내부에는 가상 함수 또는 함수 포인터 테이블을 두고 외부로는 타입 정보를 흘리지 않는다. Sean Parent는 GoingNative 2013 발표 "Inheritance Is The Base Class of Evil"에서 value semantics를 갖춘 비침습적 런타임 다형성을 시연했다.11
해결하는 문제: 템플릿 없이 다형적 컨테이너 표현, 헤더 의존성 축소, ABI 안정성.
// 표준 라이브러리의 type erasure 예
std::function<int(int)> f = [](int x) { return x * 2; };
f = some_free_function; // 시그니처만 맞으면 어떤 호출 가능 객체도 OK
std::any value = 42;
value = std::string("hello"); // 어떤 타입이든 담김
대표 사례: std::function, std::any, std::shared_ptr의 deleter.
비용: heap allocation 가능성 (Small Object Optimization으로 일부 회피), 간접 호출 비용.
EBO (Empty Base Optimization)
빈 기반 클래스가 derived 클래스에 추가 패딩을 만들지 않도록 컴파일러가 허용하는 규칙을 활용한 이디엄. 정확히는 empty base subobject가 derived의 다른 subobject와 같은 주소를 차지할 수 있어서 조건이 맞으면 추가 공간을 없앨 수 있다.12
해결하는 문제: 정책 클래스, allocator 등 상태 없는 타입도 멤버로 두면 최소 1바이트를 차지하고, 정렬 패딩이 붙으면 그보다 커진다. 조건이 맞아 EBO가 적용되면 기반 클래스 부분의 추가 공간을 없앨 수 있다.
struct EmptyDeleter {};
template<typename T, typename Deleter>
class UniquePtr : private Deleter // EBO: 조건이 맞으면 빈 Deleter의 추가 공간을 없앨 수 있다.
{
T* ptr;
};
C++20부터는 멤버에 [[no_unique_address]] 속성을 붙여 같은 최적화를 받을 수 있다. 그래서 EBO를 위해 일부러 상속을 쓰는 일은 점점 줄어드는 추세.
5. STL 사용 이디엄
Erase-remove idiom
컨테이너에서 조건에 맞는 원소를 제거할 때 std::remove_if와 erase를 함께 쓰는 패턴.13
해결하는 문제: std::remove_if는 이름과 달리 원소를 실제로 삭제하지 않는다. 남길 원소를 앞으로 당겨 채우고 새 logical end iterator를 반환할 뿐이다. 지울 원소를 뒤로 옮기는 것이 아니다. 진짜 삭제는 erase가 한다. 이 사실을 모르면 컨테이너 크기가 줄지 않고, 뒤쪽 구간의 원소들이 valid but unspecified(또는 moved-from) 상태로 남는다.
// C++20 이전 - 표준 이디엄
v.erase(
std::remove_if(v.begin(), v.end(),
[](int x) { return x < 0; }),
v.end());
// C++20 이후 - 같은 동작의 단축형
std::erase_if(v, [](int x) { return x < 0; });
std::list 같은 노드 기반 컨테이너는 멤버 함수 remove_if를 따로 가지며 진짜로 삭제한다. 컨테이너별로 동작이 다르다는 점이 함정.
부록: idiom과 자주 혼동되는 언어 기능
이 둘은 named idiom이 아니라 C++11 언어 기능이다. idiom은 이 기능을 안전하게 활용하는 패턴들이다.
range-based for
C++11 syntax. iterator를 명시하지 않고 컬렉션을 순회. 이디엄이라기보단 권장 사용법.14
for (const auto& item : container) { /* ... */ }
for (auto& item : container) { /* 수정 가능 */ }
관련 이디엄: 인덱스가 필요하면 C++23의 std::views::enumerate를 사용할 수 있지만, 표준 라이브러리 구현 지원이 환경별로 다르다. 지원이 부족한 환경에서는 별도 카운터, range-v3, zip view + iota 조합 등을 사용한다.
move semantics
C++11 언어 기능. lvalue/rvalue 참조와 std::move로 리소스를 복사 대신 이전. 메커니즘 자체는 이디엄이 아니다.15
관련 이디엄들:
Rule of Five: 이동 가능 클래스 설계
Move-only types:
std::unique_ptr처럼 복사 금지하고 이동만 허용Sink parameter: 인자를 값으로 받고 내부에서 move하여 호출자가 복사할지 이동할지 선택하게 함
Perfect forwarding:
std::forward<T>로 인자의 value category 보존noexcept 이동: 복사 가능한 타입을 std::vector가 재할당할 때, 예외 보장을 위해 이동 대신 복사를 선택할 수 있다. 이동 생성자에
noexcept를 붙이면 이 복사를 피할 수 있다
// Sink parameter 이디엄
class Builder
{
public:
void set_name(std::string n) // 값으로 받기
{
name = std::move(n); // 내부에서 이동
}
private:
std::string name;
};
정리
분류 | 이디엄 |
|---|---|
리소스 관리 | RAII, Rule of Zero/Three/Five, Smart pointer ownership, copy-and-swap |
캡슐화 | Pimpl, NVI, Type erasure |
타입 표현 | std::optional, std::variant + std::visit |
컴파일 타임 | CRTP, EBO |
STL | Erase-remove |
(언어 기능) | range-based for, move semantics |
- 분류
리소스 관리
- 이디엄
RAII, Rule of Zero/Three/Five, Smart pointer ownership, copy-and-swap
- 분류
캡슐화
- 이디엄
Pimpl, NVI, Type erasure
- 분류
타입 표현
- 이디엄
std::optional, std::variant + std::visit
- 분류
컴파일 타임
- 이디엄
CRTP, EBO
- 분류
STL
- 이디엄
Erase-remove
- 분류
(언어 기능)
- 이디엄
range-based for, move semantics
복잡한 도구를 쓴다고 사람이 깊어지는 것은 아니다.
때로는 단지 복잡한 도구를 합리화하는 데 익숙해질 뿐이다.
개인적인 메모: C++ 커뮤니티는 버전이 지나치게 많고, 표준도 복잡하고, 생태계도 파편화되어 있는데도 특유의 우월주의가 강하다.
저수준 제어를 한다는 자부심과, 현대적 안전성이나 생산성에 대한 경멸이 이상하게 섞여 있다.솔직히 별로 가까워지고 싶은 문화는 아니다.
그렇게까지 저수준 제어가 인생의 목적이라면 차라리 어셈블리를 쓰는 편이 더 일관적이지 않나 싶다.
같이 보기
각주
- RAII. Bjarne Stroustrup이 C++의 자원 관리 원칙으로 정립. - cppreference: RAII - 생성자에서 리소스를 획득하고 모든 class invariant를 확립하며, 소멸자에서 리소스를 해제하고 예외를 던지지 않는다는 기본 규약 - Wikipedia: Resource acquisition is initialization - C++ 기원, Ada, Vala, Rust에서도 관련 개념 사용 ↩
- Bjarne Stroustrup, Herb Sutter (eds.), C++ Core Guidelines, R.1: Manage resources automatically using resource handles and RAII, CP.20: Use RAII, never plain lock()/unlock(). ↩
- Rule of Zero / Three / Five. 아래 ACCU 역사 해설은 Rule of Three의 명명을 Marshall Cline의 1991년 기록으로 추적한다. - cppreference: Rule of three/five/zero - C++ Core Guidelines C.20 (Rule of Zero) - C++ Core Guidelines C.21 (Rule of Five) - ACCU Overload #120: Rule of Zero/Three/Five 역사 정리 - Stroustrup, Sutter/Alexandrescu, Walter Brown의 N3839까지 추적 - Fluent C++: The Rule of Zero - Scott Meyers의 "Rule of Five Defaults" 반론 포함 ↩
- Smart pointer ownership. - C++ Core Guidelines R.20–R.34 (Resource Management) - C++ Core Guidelines F.7 - non-owning은 raw pointer/reference로 받으라는 규칙 - cppreference: std::unique_ptr - cppreference: std::shared_ptr - cppreference: std::weak_ptr ↩
- copy-and-swap. Herb Sutter의 Guru of the Week #59(1999)를 참고한 예제. - GotW #59: Exception-Safe Class Design, Part 1 - Stack Overflow: What is the copy-and-swap idiom? - 커뮤니티 표준 설명 - Mropert: copy-and-swap, 20 years later - strong exception guarantee 비용과 move 의미론과의 충돌 정리 ↩
- Pimpl (Pointer to Implementation). Herb Sutter의 GotW 시리즈가 표준 출처. - GotW #24: Compilation Firewalls - 원본 - GotW #100: Compilation Firewalls (C++11) - private 데이터/멤버를 어디까지 impl에 넣을지 설계 선택지 평가 - GotW #101: Compilation Firewalls, Part 2 - C++ Stories: The Pimpl Pattern - d-pointer, compiler firewall, Cheshire Cat, Opaque pointer 동의어 정리 ↩
- NVI (Non-Virtual Interface). Herb Sutter가 2001년 C/C++ Users Journal에 발표. - Sutter: Virtuality - NVI를 명시적으로 권장한 가장 유명한 글 - C++ Core Guidelines C.133: Avoid protected data ↩
- std::optional. - cppreference: std::optional - C++ Core Guidelines F.60 - pointer 대신 optional 권장 맥락 - cppreference: std::expected (C++23) - 더 풍부한 대안 ↩
- std::variant + std::visit. - cppreference: std::variant - cppreference: std::visit - C++ Core Guidelines C.181: Avoid naked unions - variant를 union 대신 권장 ↩
- CRTP (Curiously Recurring Template Pattern). James O. Coplien이 1995년 C++ Report에서 명명. - Coplien (1995): Curiously Recurring Template Patterns (PDF) - 원전 - Wikipedia: Curiously recurring template pattern - F-bound polymorphism의 일종, Windows ATL/WTL에서 광범위하게 사용 - Fluent C++: The Curiously Recurring Template Pattern - 실용 해설 시리즈 ↩
- Type erasure. Sean Parent의 GoingNative 2013 발표에서 value semantics를 갖춘 런타임 다형성을 시연. - Microsoft Learn: Inheritance Is The Base Class of Evil - value semantics 기반 비침습적 런타임 다형성 시연 - YouTube: Sean Parent - Inheritance Is The Base Class of Evil - GitHub gist: martinmoene/cd3286daa799acc55cc0 - 발표 코드 정리 - Alexandrescu, Andrei. Modern C++ Design (2001), 5장 "Generalized Functors" - 호출 가능 객체를 하나의 Functor 타입 뒤로 감추는 구현 - Iglberger, Klaus. Breaking Dependencies: Type Erasure - A Design Analysis (CppCon) ↩
- EBO (Empty Base Optimization). - cppreference: Empty base optimization - cppreference: no_unique_address (C++20) - 멤버에 대한 현대적 대안 - Boost: compressed_pair - EBO의 실용 응용 예시 ↩
- Erase-remove idiom. - cppreference: std::remove, std::remove_if - "왜 그냥 지우지 않는가" 설명 포함 - cppreference: std::erase, std::erase_if (C++20) - Meyers, Scott. Effective STL, Item 32: "Follow remove-like algorithms by erase if you really want to remove something" ↩
- range-based for. - cppreference: Range-based for loop - C++ Core Guidelines ES.71 - range-for를 일반 for보다 우선 ↩
- move semantics. - cppreference: Move constructors - C++ Core Guidelines F.18 (sink parameter) - Meyers, Scott. Effective Modern C++, Items 23–30 (rvalue references, move, forward) ↩