Folly Code Review · 25/89

folly::StringPiece — string_view 호환 분석

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

cpp folly stringpiece string-view strings

#한 줄 요약

folly::StringPiece는 Range<const char*>의 alias로, std::string_view 이전 시대의 read-only view다. 지금은 두 타입이 implicit 변환되므로 함수 시그니처는 무엇을 써도 되지만 fbcode 관성으로 StringPiece가 우세하다.

#동기

std::string_view는 C++17에 도입됐다. fbcode는 그 7년 전인 2010년부터 같은 개념의 StringPiece(Google이 먼저 제안)를 써왔다. 코드베이스 관성, ABI 안정성, 그리고 Range<T*> 일반화의 한 경우라는 디자인 가치 때문에 deprecated 되지 않고 남아 있다.

1
// 모두 등가 — 함수 boundary에서 view 전달
2
void Process(folly::StringPiece s);
3
void Process(std::string_view s);
4
void Process(folly::Range<const char*> s);

핵심은 어떤 형태의 contiguous read-only 문자열도 함수가 받을 수 있게 하는 것. std::string, fbstring, const char*, 리터럴, 부분 substring 모두 변환된다.

#API & 사용법

1
#include <folly/Range.h>
2

3
// 1. 생성 — 어디서든
4
folly::StringPiece sp1 = "literal";
5
folly::StringPiece sp2{std::string{"std::string"}};
6
folly::StringPiece sp3{fb_string};
7
folly::StringPiece sp4{sv};                       // std::string_view에서
8
folly::StringPiece sp5{buf, n};                   // (ptr, len)
9

10
// 2. 표준 view 인터페이스
11
sp1.size();        sp1.empty();
12
sp1.data();        sp1.front();
13
sp1.starts_with("li");
14
sp1.ends_with("al");
15
sp1.find('e');
16

17
// 3. Range 인터페이스 (folly만의 추가)
18
sp1.subpiece(2, 3);          // "ter"
19
sp1.removePrefix("lit");     // sp1이 "eral"로 mutate
20
sp1.removeSuffix("al");      // sp1이 "lit" 으로
21
sp1.split_step(' ');         // delimiter로 잘라 앞 조각 반환
22

23
// 4. std::string_view로 명시 변환
24
std::string_view sv = sp1;   // implicit OK
25
auto sv2 = sp1.toFmt();      // fmt가 인식하는 형태

removePrefix/removeSuffix/split_step은 view를 in-place로 진행시킨다. parser에서 token을 잘라낼 때 새 객체 없이 진행할 수 있어 가볍다.

#내부 구현

1
// folly/Range.h 의 약식
2
template <class Iter>
3
class Range {
4
  Iter b_;       // begin
5
  Iter e_;       // end
6
public:
7
  constexpr Range() : b_(), e_() {}
8
  constexpr Range(Iter b, Iter e) : b_(b), e_(e) {}
9
  constexpr Range(Iter b, size_t n) : b_(b), e_(b + n) {}
10

11
  // const char* + size_t 특화 등 다수 ctor
12
  /* implicit */ Range(const std::string& s)
13
    : b_(s.data()), e_(s.data() + s.size()) {}
14

15
  constexpr size_t size() const { return e_ - b_; }
16
  constexpr Iter data() const { return b_; }
17
  // ...
18
};
19

20
using StringPiece = Range<const char*>;
21
using MutableStringPiece = Range<char*>;
22
using ByteRange = Range<const unsigned char*>;
23
using MutableByteRange = Range<unsigned char*>;

두 포인터(begin/end)만 들고 다닌다. std::string_view가 (ptr, len)인 것과 representation이 다르다. 의미는 같지만 ABI는 호환되지 않는다.

folly::Range는 char에 한정되지 않는다. ByteRange(uint8_t*), MutableStringPiece(char*), 사용자 타입 포인터 등 모든 contiguous range를 같은 타입 family로 다룰 수 있다. IOBuf::coalesce()가 ByteRange를 반환하는 이유다.

#split_step의 진행 의미

1
folly::StringPiece line = "user:42:active";
2
auto user   = line.split_step(':');   // "user", line은 "42:active"
3
auto id     = line.split_step(':');   // "42",   line은 "active"
4
auto status = line;                   // "active"

line이 in-place로 줄어들면서 token을 하나씩 반환한다. heap 할당 0, 추가 buffer 0. 큰 log 파일을 parse할 때 성능 차이가 크다.

#std::string_view 비교

항목	`folly::StringPiece`	`std::string_view`
Representation	(begin, end)	(ptr, size)
도입 시기	2010 (folly)	C++17
`starts_with`	O	O (C++20)
`removePrefix(StringPiece)`	O (substring 매칭)	X (chars만)
`split_step`	O	X
general Range alias	O (`Range<T*>`)	X (char/wchar 한정)
ADL hash	`folly::hasher`	`std::hash`
`constexpr`	C++14 한정	전체 constexpr

std::string_view::remove_prefix(n)는 n개 char만 떼는 반면, StringPiece::removePrefix(sp)는 prefix가 일치하면 잘라낸다. 두 의미가 같은 이름을 공유해 혼동이 생긴다(folly가 더 일찍 정의했다).

#코드 리뷰 포인트

1
// Bad — 새 코드에서 std::string으로 받음
2
void Tokenize(const std::string& input);    // 호출자가 변환 강제
3

4
// Good — view로 받아 모든 호출자 흡수
5
void Tokenize(folly::StringPiece input);

함수가 데이터를 소유하지 않으면 view로 받는다. const std::string&는 const char* literal을 받으면 임시 std::string을 만들어 할당이 일어난다.

1
// 위험 — 임시에서 view 잡기
2
folly::StringPiece bad = std::string("temp");   // dangling!
3
LOG(INFO) << bad;                                // UB
4

5
// 안전 — 생존을 보장하는 source
6
const std::string& s = GetString();              // refer to long-lived
7
folly::StringPiece ok = s;

StringPiece는 view 라서 lifetime을 직접 관리하지 않는다. 임시 객체에서 뽑으면 dangle 한다.

1
// 미묘 — Range가 nullptr이 아닌 빈 view를 가질 수 있다
2
folly::StringPiece e1;                    // size==0, data==nullptr
3
folly::StringPiece e2 = "";               // size==0, data!=nullptr
4
e1.data();   // nullptr — c_str로 못 씀
5
e2.data();   // ""    — c_str OK

StringPiece는 NUL-terminated를 보장하지 않는다. c_str()이 필요한 C API에는 to<std::string>(sp).c_str()로 복사 후 전달.

#안티패턴

std::string_view와 StringPiece를 한 코드베이스에 혼재: 변환은 implicit이지만 hash·comparator·overload set이 충돌할 수 있다. 새 모듈은 한 쪽으로 통일.
StringPiece에서 c_str() 호출 시도: 그런 멤버는 없다. NUL terminate가 필요한 곳은 view를 쓰지 않는다.
multi-thread에서 removePrefix 등 mutating 호출: 진행형 in-place 연산이라 같은 view를 두 스레드가 mutate하면 race. view는 thread-local로.