C++ Range Adaptor | "범위 어댑터" 가이드

Range Adaptor란?

범위를 변환하는 함수 객체 (C++20)

#include <ranges>

std::vector<int> v = {1, 2, 3, 4, 5};

// 어댑터: 범위 -> 뷰
auto filtered = v | std::views::filter( { return x > 2; });

기본 사용

namespace vws = std::views;

std::vector<int> v = {1, 2, 3, 4, 5};

// 어댑터 적용
auto view1 = vws::filter(v,  { return x > 2; });

// 파이프라인
auto view2 = v | vws::filter( { return x > 2; });

실전 예시

예시 1: 파이프라인 조합

#include <ranges>
#include <vector>

std::vector<int> numbers = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 여러 어댑터 조합
auto pipeline = numbers
    | std::views::filter( { return x % 2 == 0; })  // 짝수
    | std::views::transform( { return x * x; })    // 제곱
    | std::views::take(3);                                   // 처음 3개

for (int x : pipeline) {
    std::cout << x << " ";  // 4 16 36
}

예시 2: 재사용 가능한 어댑터

#include <ranges>

// 어댑터 저장
auto evenFilter = std::views::filter( { return x % 2 == 0; });
auto square = std::views::transform( { return x * x; });

std::vector<int> v1 = {1, 2, 3, 4, 5};
std::vector<int> v2 = {6, 7, 8, 9, 10};

// 재사용
auto result1 = v1 | evenFilter | square;
auto result2 = v2 | evenFilter | square;

예시 3: 커스텀 어댑터

#include <ranges>

// 커스텀 어댑터: 홀수만
auto odds = std::views::filter( { return x % 2 != 0; });

// 커스텀 어댑터: 3의 배수만
auto multiplesOf3 = std::views::filter( { return x % 3 == 0; });

std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

auto result = v | odds;  // 1 3 5 7 9

예시 4: 조건부 어댑터

#include <ranges>

template<typename Range>
auto conditionalFilter(Range&& r, bool applyFilter) {
    if (applyFilter) {
        return std::forward<Range>(r) 
            | std::views::filter( { return x > 5; });
    } else {
        return std::forward<Range>(r) | std::views::all;
    }
}

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    
    auto result = conditionalFilter(v, true);
    
    for (int x : result) {
        std::cout << x << " ";  // 6 7 8 9 10
    }
}

주요 어댑터

namespace vws = std::views;

// 필터링
vws::filter(pred)
vws::take(n)
vws::drop(n)
vws::take_while(pred)
vws::drop_while(pred)

// 변환
vws::transform(func)
vws::reverse

// 분할/결합
vws::split(delimiter)
vws::join

// 생성
vws::iota(start)
vws::iota(start, end)

// 기타
vws::all  // 전체 뷰
vws::counted(it, n)
vws::common

자주 발생하는 문제

문제 1: 타입 추론

// ❌ 복잡한 타입
std::vector<int> v = {1, 2, 3};
std::ranges::filter_view<std::ranges::ref_view<std::vector<int>>, /* ... */> filtered = 
    v | std::views::filter( { return x > 1; });

// ✅ auto
auto filtered = v | std::views::filter( { return x > 1; });

문제 2: 어댑터 순서

std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

// 순서에 따라 결과 다름
auto r1 = v | std::views::reverse | std::views::take(3);
// 10 9 8

auto r2 = v | std::views::take(3) | std::views::reverse;
// 3 2 1

문제 3: 수명 관리

// ❌ 임시 객체
auto getView() {
    std::vector<int> v = {1, 2, 3};
    return v | std::views::filter( { return x > 1; });
    // v 소멸
}

// ✅ 소유 또는 참조 명확화
auto getView(const std::vector<int>& v) {
    return v | std::views::filter( { return x > 1; });
}

문제 4: 성능

// 지연 평가: 매번 재계산
auto view = v | std::views::filter(pred) | std::views::transform(func);

for (int x : view) { /* ... */ }  // 계산
for (int x : view) { /* ... */ }  // 다시 계산

// ✅ 한 번만 계산 필요 시
std::vector<int> cached(view.begin(), view.end());
for (int x : cached) { /* ... */ }  // 캐시 사용
for (int x : cached) { /* ... */ }  // 캐시 사용

어댑터 조합

namespace vws = std::views;

// 파이프라인
auto pipeline = vws::filter(pred) 
              | vws::transform(func) 
              | vws::take(n);

// 적용
std::vector<int> v = {1, 2, 3, 4, 5};
auto result = v | pipeline;

FAQ

Q1: Range Adaptor는?

A: 범위를 뷰로 변환.

Q2: 파이프라인?

A: | 연산자로 조합.

Q3: 지연 평가?

A: 순회 시 계산.

Q4: 재사용?

A: 어댑터 저장 후 재사용 가능.

Q5: 순서?

A: 중요. 효율성 영향.

Q6: 학습 리소스는?

A:

• “C++20 Ranges”
• “C++20 The Complete Guide”
• cppreference.com

---

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

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

• C++ Range Algorithms | “범위 알고리즘” 가이드
• C++ Ranges | “범위 라이브러리” 가이드
• C++ Views | “뷰” 가이드

관련 글

• C++20 Ranges | begin/end 반복 탈출하고 ranges 알고리즘 쓰기
• C++ Range Algorithms |
• C++ Ranges 기본 개념 |
• C++ Barrier & Latch |
• C++ Branch Prediction |