Folly Code Review · 72/89

folly::Range — 일반 iterator pair

2026년 6월 8일 · Hawk · 3분 읽기

한 줄 요약: Range<Iter>는 두 iterator를 묶은 view 타입이다. StringPiece(=Range<const char*>)의 일반화이며, std::span/std::string_view보다 먼저 도입돼 둘의 역할을 통합 표현한다.

#동기

std::span(C++20)과 std::string_view(C++17)는 표준에 따로 들어왔다. 둘 다 iterator pair view라는 본질은 같지만 도메인을 분리한 결과다.

1
표준
2
  std::string_view  ← char (and char_traits)
3
  std::span<T>      ← T (and extent)
4

5
folly
6
  Range<T*>         ← 임의 contiguous
7
    using StringPiece = Range<const char*>
8
    using MutableStringPiece = Range<char*>
9
    using ByteRange = Range<const uint8_t*>

Range는 iterator pair만 추상화한다. 그게 contiguous한지, char인지, byte인지는 alias로 분기. 결과적으로 같은 코드베이스에서 모든 view가 일관된 인터페이스를 가진다.

1
#include <folly/Range.h>
2

3
folly::StringPiece s = "hello";              // Range<const char*>
4
folly::ByteRange   b(data, len);             // Range<const uint8_t*>
5
folly::Range<int*> r(arr.data(), arr.size()); // Range<int*>
6

7
// 모두 begin/end/size/empty/subpiece/split_step 동일

#API

1
folly::StringPiece s = "hello world";
2

3
s.size();        // 11
4
s.empty();       // false
5
s.front();       // 'h'
6
s.back();        // 'd'
7
s[0];            // 'h'
8

9
// substring (in-place, no alloc)
10
auto first5 = s.subpiece(0, 5);    // "hello"
11
auto rest   = s.subpiece(6);       // "world"
12

13
// scan
14
s.find("wor");           // 6
15
s.startsWith("hello");   // true
16
s.endsWith("world");     // true
17

18
// split-style iteration
19
folly::StringPiece csv = "a,b,c,d";
20
folly::StringPiece tok;
21
while (folly::split(",", csv, tok, /*ignoreEmpty=*/false)) {
22
  process(tok);
23
}

StringPiece 멤버 대부분이 std::string_view와 시그니처가 같다 — 마이그레이션이 쉽다.

#subpiece — slice without copy

1
folly::StringPiece line = ReadLine();   // 외부 buffer 가리킴
2
auto key   = line.subpiece(0, 5);
3
auto value = line.subpiece(6);
4
// key/value 모두 line의 backing buffer 공유 — 할당 없음

subpiece(offset, length)가 핵심 연산. std::string::substr은 복사지만 StringPiece::subpiece는 view 조정. parser가 빈번히 호출하는 자리에서 비용이 결정적이다.

#split_step

1
folly::StringPiece input = "key=value;type=int;ttl=300";
2

3
while (!input.empty()) {
4
  auto field = input.split_step(';');
5
  auto k = field.split_step('=');
6
  auto v = field;
7
  // k = "key", v = "value" → ...
8
}

split_step(delim)은 제자리에서 첫 토큰을 떼어내고 입력을 갱신한다. 별도 vector 만들지 않고 streaming parse. C에서 strtok 패턴의 안전판.

#ByteRange

1
folly::ByteRange b(buffer, len);
2

3
// memmem 같은 byte 단위 scan
4
auto pos = b.find(needle);
5

6
// 다른 view로 reinterpret (주의 — 정렬)
7
folly::StringPiece sv(reinterpret_cast<const char*>(b.data()), b.size());

binary protocol parsing에 적합. IOBuf에서 raw bytes를 꺼낼 때 ByteRange가 자연스러운 인터페이스.

#내부 구현

1
// folly/Range.h 약식
2
template <class Iter>
3
class Range {
4
 public:
5
  using value_type      = typename std::iterator_traits<Iter>::value_type;
6
  using reference       = typename std::iterator_traits<Iter>::reference;
7
  using iterator        = Iter;
8
  using const_iterator  = Iter;
9
  using size_type       = size_t;
10

11
 private:
12
  Iter b_;
13
  Iter e_;
14

15
 public:
16
  Range() : b_(), e_() {}
17
  Range(Iter b, Iter e) : b_(b), e_(e) {}
18
  Range(Iter b, size_t sz) : b_(b), e_(b + sz) {}
19

20
  iterator begin() const { return b_; }
21
  iterator end()   const { return e_; }
22
  size_t   size()  const { return e_ - b_; }
23
  bool     empty() const { return b_ == e_; }
24

25
  auto subpiece(size_t off, size_t len = npos) const {
26
    auto newB = b_ + off;
27
    auto newE = (len == npos) ? e_ : newB + std::min(len, size_t(e_ - newB));
28
    return Range(newB, newE);
29
  }
30
};

본질은 두 iterator일 뿐이다. 16 byte (64-bit pointer 두 개) sizeof. constexpr 가능.

#StringPiece-specific

1
using StringPiece = Range<const char*>;
2

3
// std::string과의 변환
4
StringPiece(const std::string& s) : b_(s.data()), e_(s.data() + s.size()) {}
5
StringPiece(const char* s)        : b_(s),        e_(s + std::strlen(s)) {}
6
StringPiece(const char* s, size_t n) : b_(s), e_(s + n) {}

std::string을 묵시적으로 받는다. API 경계에서 void foo(folly::StringPiece s) 한 줄로 std::string, const char*, std::string_view 모두 받는다.

#std::span / std::string_view와의 비교

항목	std::span	std::string_view	folly::Range
도입	C++20	C++17	folly (수년 전)
타입	T pointer + size	const char* + size	Iter pair
정수 extent	static / dynamic	always dynamic	always dynamic
변환	다양 (contiguous 컨테이너)	string-like	std::string + char* + std::string_view
멤버	일부 (subspan 등)	풍부	string_view 수준 + split_step
mutability	있음	항상 const	Iter 타입에 의존

표준은 use case마다 타입을 분리했다. folly는 iterator pair 하나로 통일. 어느 쪽이 옳다기보다 통일성 vs 도메인 명확성 trade-off.

마이그레이션 관점: StringPiece를 std::string_view로 바꿀 수 있다. API가 거의 호환. split_step 같은 일부 멤버는 free function으로 대체.

1
// folly StringPiece
2
folly::StringPiece sp = "hello,world";
3
auto tok = sp.split_step(',');
4

5
// std::string_view + free function
6
std::string_view sv = "hello,world";
7
auto pos = sv.find(',');
8
auto tok = sv.substr(0, pos);
9
sv.remove_prefix(pos + 1);

표준이 동등한 표현력은 갖되 몇 줄 더 쓴다.

#코드 리뷰 포인트

함수가 const std::string& 받음 → StringPiece 또는 std::string_view로 바꿔 호출자 부담 줄임.
StringPiece 변수를 원본 lifetime 밖에서 사용 → 명백한 UAF. lambda capture by reference도 위험.
subpiece 후 인덱스 계산이 원본 기준인지 sub 기준인지 헷갈리는 코드.
split vs split_step 선택 — 결과 컨테이너 필요하면 split, streaming이면 split_step.
ByteRange/StringPiece 간 reinterpret 시 char 부호 차이 주의.

#자주 보는 안티패턴

1
// 1. StringPiece를 반환하면서 local std::string 가리킴
2
folly::StringPiece BuildKey(int id) {
3
  std::string s = "k" + std::to_string(id);
4
  return s;   // UAF — s 소멸
5
}
6

7
// 2. std::string으로 받았다가 StringPiece로 즉시 변환
8
void Process(const std::string& s) {
9
  folly::StringPiece sp(s);
10
  parse(sp);
11
}
12
// → 처음부터 Process(folly::StringPiece) 가 옳음
13

14
// 3. StringPiece에 strlen 호출
15
auto len = strlen(sp.data());   // sp가 null-terminated 보장 없음 — UB
16

17
// 4. subpiece 범위 미체크
18
auto sub = sp.subpiece(off, len);   // off > sp.size() 면 UB