C++ subrange | "부분 범위" 가이드

subrange란?

반복자 쌍을 범위로 (C++20)

#include <ranges>

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

// 반복자 쌍 -> subrange
std::ranges::subrange sr{v.begin() + 1, v.begin() + 4};

for (int x : sr) {
    std::cout << x << " ";  // 2 3 4
}

기본 사용

#include <ranges>
#include <vector>

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

// 생성
std::ranges::subrange sr1{v.begin(), v.end()};
std::ranges::subrange sr2{v.begin() + 1, v.begin() + 4};

// 크기
std::cout << sr2.size() << std::endl;  // 3

실전 예시

예시 1: 범위 분할

#include <ranges>
#include <algorithm>

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

// 중간 지점
auto mid = v.begin() + v.size() / 2;

// 두 부분으로 분할
std::ranges::subrange first{v.begin(), mid};
std::ranges::subrange second{mid, v.end()};

std::cout << "첫 번째: ";
for (int x : first) {
    std::cout << x << " ";  // 1 2 3 4 5
}

std::cout << "\n두 번째: ";
for (int x : second) {
    std::cout << x << " ";  // 6 7 8 9 10
}

예시 2: 알고리즘 결과

#include <ranges>
#include <algorithm>

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

// find_if는 반복자를 반환 — 끝까지의 부분 범위는 subrange로 감싼다
auto it = std::ranges::find_if(v, [](int x) { return x > 5; });
std::ranges::subrange result{it, v.end()};

std::cout << "찾은 값부터: ";
for (int x : result) {
    std::cout << x << " ";  // 6 7 8 9 10
}

예시 3: 뷰 생성

#include <ranges>

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

// subrange -> 뷰
std::ranges::subrange sr{v.begin() + 1, v.begin() + 4};

auto doubled = sr | std::views::transform([](int x) { return x * 2; });

for (int x : doubled) {
    std::cout << x << " ";  // 4 6 8
}

예시 4: 범위 순회

#include <ranges>

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

// 청크로 분할
constexpr size_t chunkSize = 3;

for (size_t i = 0; i < v.size(); i += chunkSize) {
    auto end = std::min(i + chunkSize, v.size());
    std::ranges::subrange chunk{v.begin() + i, v.begin() + end};
    
    std::cout << "청크: ";
    for (int x : chunk) {
        std::cout << x << " ";
    }
    std::cout << std::endl;
}
// 청크: 1 2 3
// 청크: 4 5 6
// 청크: 7 8 9
// 청크: 10

subrange 속성

std::ranges::subrange sr{v.begin(), v.end()};

// 반복자
auto begin = sr.begin();
auto end = sr.end();

// 크기 (가능한 경우)
auto size = sr.size();

// 비어있는지
bool empty = sr.empty();

// 앞 요소
auto& front = sr.front();

// 뒤 요소 (양방향 범위)
auto& back = sr.back();

자주 발생하는 문제

문제 1: 수명

// ❌ 댕글링
std::ranges::subrange getSubrange() {
    std::vector<int> v = {1, 2, 3};
    return {v.begin(), v.end()};
    // v 소멸
}

// ✅ 참조 명확화
std::ranges::subrange getSubrange(std::vector<int>& v) {
    return {v.begin(), v.end()};
}

문제 2: 크기

// 크기를 알 수 없는 범위
std::list<int> lst = {1, 2, 3};
std::ranges::subrange sr{lst.begin(), lst.end()};

// ❌ size() 없음 (양방향 반복자)
// auto size = sr.size();  // 에러

// ✅ distance
auto size = std::ranges::distance(sr);

문제 3: 타입 추론

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

// ✅ 명시적 타입
std::ranges::subrange<std::vector<int>::iterator> sr{v.begin(), v.end()};

// ✅ auto
auto sr = std::ranges::subrange{v.begin(), v.end()};

문제 4: 범위 수정

std::vector<int> v = {1, 2, 3, 4, 5};
std::ranges::subrange sr{v.begin() + 1, v.begin() + 4};

// subrange 통해 수정 가능
for (int& x : sr) {
    x *= 2;
}

// v: {1, 4, 6, 8, 5}

활용 패턴

// 1. 범위 분할
std::ranges::subrange first{v.begin(), mid};
std::ranges::subrange second{mid, v.end()};

// 2. 알고리즘 결과
auto result = std::ranges::find_if(v, pred);

// 3. 뷰 생성
auto view = sr | std::views::transform(func);

// 4. 청크 처리
for (size_t i = 0; i < v.size(); i += chunkSize) {
    std::ranges::subrange chunk{...};
}

C++20 Ranges 라이브러리와의 위치

C++20에서 <ranges>는 Range 개념(begin/end로 순회 가능한 타입)을 표준화하고, 알고리즘은 std::ranges:: 네임스페이스에 Range 버전으로 정리되었습니다. std::ranges::subrange는 그중에서도 “반복자 쌍 [first, last)를 하나의 Range로 포장한 어댑터” 역할을 합니다.

• 뷰(view) 와 달리 subrange는 보통 기존 시퀀스의 일부를 참조합니다. views::take/filter 등은 지연 연산 체인의 한 고리이고, subrange는 이미 존재하는 컨테이너의 슬라이스를 알고리즘에 넘기기 좋습니다.
• std::ranges::dangling 과 함께 쓰일 때가 있는데, 임시 객체에서 begin만 뽑아 쓰는 실수를 줄이기 위한 패턴입니다. 임시 vector에 대한 subrange 반환은 여전히 수명 버그가 나기 쉬우므로, 반환형 API 설계 시 주의합니다.

#include <ranges>
#include <vector>
#include <algorithm>

void sort_tail(std::vector<int>& v, std::size_t n) {
    if (n >= v.size()) return;
    auto first = v.begin() + static_cast<std::ptrdiff_t>(v.size() - n);
    std::ranges::subrange tail{first, v.end()};
    std::ranges::sort(tail);
}

subrange와 std::span 비교

관점	std::ranges::subrange	std::span (C++20)
표현	반복자 쌍 [begin, end)	연속 요소 블록 (data, size) 또는 배열 참조
컨테이너	임의 시퀀스(리스트 등) 슬라이스에도 적합	연속 메모리(contiguous_range)에 최적화
알고리즘	Range 알고리즘과 조합	주로 인덱스/버퍼 처리, 저수준 API
크기	반복자 종류에 따라 size()가 없을 수 있음	size() 항상(고정/동적 span)

문자열 파싱 버퍼, 고정 크기 윈도우, C API와의 경계에서는 **span**이 자연스럽고, 중간부터 끝까지 잘라 sort/find 등에 넘길 때는 **subrange**가 자연스럽습니다. 둘 다 비소유(non-owning) 이므로 원본 수명은 동일하게 관리해야 합니다.

#include <span>
#include <vector>

void fill_span(std::span<int> s);  // 연속 버퍼

void by_iterators(std::vector<int>& v) {
    std::ranges::subrange part{v.begin() + 1, v.end()};
    for (int x : part) { (void)x; }
}

실전 활용 보강

• 병렬 파이프라인: 큰 vector를 구간으로 나눠 subrange 단위로 워커에 넘기면, 데이터 복사 없이 부분 구간만 처리하게 할 수 있습니다(단, 동시 쓰기는 동기화 필요).
• 파싱/토큰 버퍼: 원본 문자열은 그대로 두고 [it, end)만 넘겨 단계별 파서를 작성하면, string_view와 조합해 할당을 줄일 수 있습니다.
• Range 파이프: subrange를 만든 뒤 views::transform/filter를 붙이면, 슬라이스 + 지연 변환을 한 흐름으로 표현할 수 있습니다.

성능 관점

• 복사 비용: subrange 객체 자체는 반복자 두 개(및 필요 시 크기/종류 정보) 수준이라 가볍습니다. 비용의 대부분은 참조하는 시퀀스를 순회하는 알고리즘 쪽입니다.
• 캐시: subrange가 연속 메모리를 가리키면 span과 유사하게 캐시 친화적이지만, 리스트 등 비연속 컨테이너면 반복자 순회 비용은 그대로입니다.
• 중간 객체: 파이프라인을 길게 이으면 컴파일러는 잘 최적화하지만, 디버그 빌드에서는 추상화 계층이 늘어날 수 있으므로, 핫 루프는 프로파일 후 단순 반복문과 비교하는 것이 좋습니다.

FAQ

Q1: subrange는?

A: 반복자 쌍을 범위로.

Q2: 용도는?

A:

• 범위 분할
• 알고리즘 결과
• 뷰 생성

Q3: 크기?

A: 임의 접근 반복자만 O(1).

Q4: 수정?

A: 가능. 원본 수정.

Q5: 수명?

A: 원본 범위 수명 주의.

Q6: 학습 리소스는?

A:

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

---

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

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

• C++ Ranges | “범위 라이브러리” 가이드
• C++ Views | “뷰” 가이드
• C++ Regex Iterator | “정규식 반복자” 가이드

관련 글

• C++ Ranges 파이프라인·뷰 |
• C++ Ranges 기본 개념 |
• C++20 Ranges | begin/end 반복 탈출하고 ranges 알고리즘 쓰기
• C++ Ranges Views와 파이프라인 | 지연 연산으로 효율적으로 다루기 [#25-2]
• C++ 커스텀 Range 작성 | range 개념을 만족하는 타입 만들기 [#25-3]