C++ Fold Expressions | "파라미터 팩 접기" 가이드

Fold Expressions란?

C++17 fold expression은 가변 인자 템플릿의 파라미터 팩을 한 번에 연산자로 “접는” 문법입니다. 재귀 템플릿 없이 pack 전체에 +, &&, << 등을 적용할 수 있어 템플릿 기초를 익힌 뒤 활용하면 코드가 짧아집니다.

// C++17 이전: 재귀
template<typename T>
T sum(T value) {
    return value;
}

template<typename T, typename... Args>
T sum(T first, Args... args) {
    return first + sum(args...);
}

// C++17: Fold Expression
template<typename... Args>
auto sum(Args... args) {
    return (... + args);  // 단항 좌측 접기
}

cout << sum(1, 2, 3, 4, 5) << endl;  // 15

4가지 Fold 형태

// 1. 단항 우측 접기: (args op ...)
template<typename... Args>
auto sum1(Args... args) {
    return (args + ...);  // ((1 + 2) + 3) + 4
}

// 2. 단항 좌측 접기: (... op args)
template<typename... Args>
auto sum2(Args... args) {
    return (... + args);  // 1 + (2 + (3 + 4))
}

// 3. 이항 우측 접기: (args op ... op init)
template<typename... Args>
auto sum3(Args... args) {
    return (args + ... + 0);  // ((1 + 2) + 3) + 0
}

// 4. 이항 좌측 접기: (init op ... op args)
template<typename... Args>
auto sum4(Args... args) {
    return (0 + ... + args);  // 0 + (1 + (2 + 3))
}

단항 fold vs 이항 fold

• 단항(unary) fold: (pack op ...) 또는 (... op pack)처럼 연산자 한쪽에만 파라미터 팩이 있습니다. 팩의 각 원소만으로 접기를 만들고, 빈 팩이면 대부분의 연산자에서 ill-formed입니다(아래 빈 팩 절 참고).
• 이항(binary) fold: (pack op ... op init) 또는 (init op ... op pack)처럼 초기값(init) 이 있어, 접기 결과의 한쪽 끝을 고정합니다. 빈 팩일 때도 init이 결과가 되므로 합·곱·논리 접기에서 안전하게 쓰입니다.

같은 +라도 이항 (0 + ... + args)는 “0에서 시작해 왼쪽으로 펼친 합”이고, 단항 (... + args)는 “인자들만으로 접은 합”입니다. 의미는 비슷해 보여도 빈 팩 처리와 결합 순서(좌/우) 에서 차이가 납니다.

좌측 fold vs 우측 fold

• 좌측(left) fold (... op args): 괄호가 왼쪽부터 쌓입니다. 예: (... + args) 는 a + (b + (c + d)) 형태로 전개되는 식(연산자 결합에 따라 정확한 트리는 표준 전개 규칙 따름).
• 우측(right) fold (args op ...): 괄호가 오른쪽부터 쌓입니다. 예: (args + ...) 는 ((a + b) + c) + d 쪽으로 전개됩니다.

덧셈·곱셈처럼 결합법칙이 성립하면 좌/우 결과값은 같지만, 뺄셈·나눗셈·스트림 출력처럼 순서가 중요하면 반드시 한쪽을 골라야 합니다. 예를 들어 (cout << ... << args) 형태는 출력 순서를 코드에 가깝게 맞추기 좋습니다.

실전: 가변 인자 함수에서 fold 쓰기

가변 인자 템플릿 함수는 보통 (1) 모든 인자에 같은 연산 적용, (2) 첫 인자와 나머지를 나누는 패턴 중 하나입니다. fold는 (1)에 특히 강합니다.

template<typename... Args>
void invoke_all(Args&&... f) {
    (std::forward<Args>(f)(), ...);  // 각 Callable을 순서대로 호출
}

인자가 0개일 수 있으면 이항 fold로 초기값을 두거나, if constexpr (sizeof...(Args) == 0) 로 분기하는 편이 안전합니다.

흔한 패턴: sum, print, all_of

목적	관용적 fold	비고
합	(0 + ... + args) 또는 (... + args)	빈 팩이면 전자
곱	(1 * ... * args)	동일
모두 참	(... && args)	빈 팩이면 true (단항 && 빈 팩 규칙)
하나라도 참	논리 OR fold	빈 팩이면 false
출력	(std::cout << ... << args)	순서·스트림 타입에 주의
컨테이너에 push_back	(vec.push_back(args), ...)	쉼표 fold

논리 OR은 예를 들어 (false || ... || args)처럼 이항 fold로 초기값을 두거나, 단항 (args || ...) 형태로 쓸 수 있습니다. std::all_of 처럼 이미 값이 들어 있는 시퀀스가 아니라 인자 목록을 논리 AND로 묶을 때 (... && args) 한 줄이 가장 읽기 쉽습니다.

C++17 기능으로서의 위치

Fold expression은 C++17에 도입된 순수 컴파일 타임 구문 확장입니다. 런타임 비용은 없고, 생성되는 코드는 보통 펼쳐진(flat) 일련의 연산입니다. C++20 이후에도 가변 인자 처리의 기본 도구로 그대로 쓰이며, concepts와 함께 쓰면 “이 연산자 fold에 쓸 수 있는 타입인가?”를 제약으로 걸 수 있습니다.

지원되는 연산자

// 산술 연산자
(... + args)   // 덧셈
(... - args)   // 뺄셈
(... * args)   // 곱셈
(... / args)   // 나눗셈

// 논리 연산자
(... && args)  // AND
(... || args)  // OR

// 비트 연산자
(... & args)   // AND
(... | args)   // OR
(... ^ args)   // XOR

// 비교 연산자
(... < args)   // 작음
(... > args)   // 큼

// 기타
(... , args)   // 쉼표

실전 예시

예시 1: 출력

template<typename... Args>
void print(Args... args) {
    (cout << ... << args) << endl;
}

print("x = ", 42, ", y = ", 3.14);
// x = 42, y = 3.14

예시 2: 모든 값 확인

template<typename... Args>
bool all(Args... args) {
    return (... && args);
}

cout << all(true, true, true) << endl;   // 1
cout << all(true, false, true) << endl;  // 0

예시 3: 컨테이너에 추가

template<typename T, typename... Args>
void push_back_all(vector<T>& vec, Args... args) {
    (vec.push_back(args), ...);
}

vector<int> vec;
push_back_all(vec, 1, 2, 3, 4, 5);
// vec = {1, 2, 3, 4, 5}

예시 4: 함수 호출

template<typename... Funcs>
void call_all(Funcs... funcs) {
    (funcs(), ...);
}

void f1() { cout << "f1" << endl; }
void f2() { cout << "f2" << endl; }
void f3() { cout << "f3" << endl; }

call_all(f1, f2, f3);
// f1
// f2
// f3

예시 5: 범위 체크

template<typename T, typename... Args>
bool in_range(T value, T min, T max, Args... args) {
    return ((value >= min && value <= max) || ... || 
            (value >= args && value <= args));
}

// 또는 더 간단하게
template<typename T, typename... Args>
bool contains(T value, Args... args) {
    return ((value == args) || ...);
}

cout << contains(3, 1, 2, 3, 4, 5) << endl;  // 1
cout << contains(6, 1, 2, 3, 4, 5) << endl;  // 0

예시 6: 최소/최대값

template<typename... Args>
auto min(Args... args) {
    return (args < ...);  // 잘못됨!
}

// 올바른 구현
template<typename T>
T min(T value) {
    return value;
}

template<typename T, typename... Args>
T min(T first, Args... args) {
    T rest = min(args...);
    return first < rest ? first : rest;
}

// 또는 std::min 사용
template<typename... Args>
auto minimum(Args... args) {
    return std::min({args...});
}

cout << minimum(5, 2, 8, 1, 9) << endl;  // 1

쉼표 연산자

template<typename... Args>
void process(Args... args) {
    int dummy[] = {(cout << args << " ", 0)...};
}

process(1, 2, 3, 4, 5);
// 1 2 3 4 5

// 또는 Fold Expression
template<typename... Args>
void process2(Args... args) {
    ((cout << args << " "), ...);
}

자주 발생하는 문제

문제 1: 빈 팩

// ❌ 빈 팩 (일부 연산자만 허용)
template<typename... Args>
auto sum(Args... args) {
    return (... + args);  // 빈 팩이면 에러
}

// ✅ 초기값 제공
template<typename... Args>
auto sum(Args... args) {
    return (0 + ... + args);  // 빈 팩이면 0
}

// 빈 팩 허용 연산자: &&, ||, ,
(... && args)  // true
(... || args)  // false
(... , args)   // void()

문제 2: 연산자 우선순위

// ❌ 우선순위 혼동
template<typename... Args>
auto func(Args... args) {
    return (... + args * 2);  // 에러
}

// ✅ 명시적 괄호
template<typename... Args>
auto func(Args... args) {
    return (... + (args * 2));
}

문제 3: 타입 불일치

// ❌ 타입 불일치
auto x = (1 + ... + 3.14);  // int + double

// ✅ 명시적 타입
template<typename T, typename... Args>
T sum(Args... args) {
    return (T(0) + ... + T(args));
}

Fold vs 재귀

// 재귀 (복잡)
template<typename T>
void print(T value) {
    cout << value << endl;
}

template<typename T, typename... Args>
void print(T first, Args... args) {
    cout << first << " ";
    print(args...);
}

// Fold (간단)
template<typename... Args>
void print(Args... args) {
    ((cout << args << " "), ...);
    cout << endl;
}

FAQ

Q1: Fold Expressions는 언제 사용하나요?

A:

• 가변 인자 템플릿
• 파라미터 팩 처리
• 재귀 대체

Q2: 모든 연산자 지원?

A: 대부분의 이항 연산자 지원. 단항 연산자는 불가.

Q3: 성능은?

A: 재귀와 동일. 컴파일 시간 단축 가능.

Q4: 빈 팩은?

A: &&, ||, , 만 허용. 나머지는 초기값 필요.

Q5: C++17 이전에는?

A: 재귀 템플릿 사용.

Q6: Fold Expressions 학습 리소스는?

A:

• “C++17 The Complete Guide”
• cppreference.com
• “Effective Modern C++”

관련 글: 가변 인자 템플릿 고급, 템플릿 기초, 템플릿 인자 추론.

---

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ 가변 인자 템플릿 고급 | pack 확장과 fold 표현식
• C++ Fold Expression 완벽 가이드 | 단항·이항·쉼표 fold·커스텀 연산자 실전
• C++ 템플릿 | “제네릭 프로그래밍” 초보자 가이드
• C++ 템플릿 인자 추론 | template argument deduction 가이드

관련 글

• C++ 가변 인자 템플릿 |
• C++ auto 타입 추론 | 복잡한 타입을 컴파일러에 맡기기
• C++ CTAD |
• C++20 Concepts 완벽 가이드 | 템플릿 제약의 새 시대
• C++ constexpr if |