folly Join·Split utilities — 문자열 분해와 결합

1
std::vector<folly::StringPiece> tokens;
2
folly::split(',', "a,b,c,d", tokens);   // 4개 StringPiece, 0 alloc

1
#include <folly/String.h>
2

3
// 1. view 결과 — 0 할당
4
std::vector<folly::StringPiece> v;
5
folly::split(',', "a,b,c", v);   // view 3개
6

7
// 2. owned 결과 — 토큰별 std::string
8
std::vector<std::string> v2;
9
folly::split(',', "a,b,c", v2);
10

11
// 3. 빈 토큰 제거
12
folly::split(',', "a,,b", v, /*ignoreEmpty=*/true);
13

14
// 4. multi-char delimiter
15
folly::split("::", "a::b::c", v);
16

17
// 5. splitTo — output iterator
18
folly::splitTo<folly::StringPiece>(
19
    ',', "a,b,c", std::back_inserter(v));
20

21
// 6. split_step (StringPiece in-place)
22
folly::StringPiece line = "k=v";
23
auto key = line.split_step('=');
24
// key="k", line="v"

1
std::vector<std::string> parts = {"a", "b", "c"};
2

3
std::string s = folly::join(",", parts);          // "a,b,c"
4

5
// output iterator
6
std::string out;
7
folly::join(",", parts, out);                     // out에 append
8

9
// 임의 범위
10
folly::join(", ", {1, 2, 3});                     // "1, 2, 3" (folly::to)

1
// 약식 — folly/String.h
2
template <class Delim, class String, class OutputType>
3
void split(const Delim& delim,
4
           const String& input,
5
           std::vector<OutputType>& out,
6
           bool ignoreEmpty = false) {
7
  detail::internalSplit(
8
      delim, StringPiece(input), out, ignoreEmpty);
9
}

1
// 약식
2
void internalSplit(char delim, StringPiece in,
3
                   std::vector<StringPiece>& out, bool skipEmpty) {
4
  const char* start = in.begin();
5
  const char* end   = in.end();
6
  for (const char* p = start; p != end; ++p) {
7
    if (*p == delim) {
8
      if (!skipEmpty || start != p) {
9
        out.emplace_back(start, p);
10
      }
11
      start = p + 1;
12
    }
13
  }
14
  if (!skipEmpty || start != end) {
15
    out.emplace_back(start, end);
16
  }
17
}

1
// 약식
2
template <class Delim, class Iter>
3
std::string join(const Delim& d, Iter begin, Iter end) {
4
  // 1차 — 총 길이 계산
5
  size_t total = 0;
6
  size_t dLen  = StringPiece(d).size();
7
  for (auto it = begin; it != end; ++it) {
8
    total += StringPiece(*it).size();
9
  }
10
  if (begin != end) {
11
    total += dLen * (std::distance(begin, end) - 1);
12
  }
13

14
  // 2차 — reserve 후 append
15
  std::string result;
16
  result.reserve(total);
17
  bool first = true;
18
  for (auto it = begin; it != end; ++it) {
19
    if (!first) result.append(StringPiece(d).data(), dLen);
20
    result.append(StringPiece(*it).data(), StringPiece(*it).size());
21
    first = false;
22
  }
23
  return result;
24
}

1
// std
2
auto tokens = std::views::split(input, ',');  // C++20, view 반환
3

4
// abseil
5
std::vector<absl::string_view> v = absl::StrSplit("a,b,c", ',');
6
std::string s = absl::StrJoin({"a", "b", "c"}, ",");
7

8
// folly
9
std::vector<folly::StringPiece> v2;
10
folly::split(',', "a,b,c", v2);
11
std::string s2 = folly::join(",", v2);

1
benchmark: split 100-byte string by ','
2
  folly::split(view)        85 ns
3
  absl::StrSplit            80 ns
4
  std::ranges::split (g++)  110 ns
5
  std::string::find loop    420 ns

1
// Bad — 매번 vector<string> 할당
2
std::vector<std::string> tokens;
3
folly::split(',', input, tokens);   // N개 string alloc
4

5
// Good — view면 충분할 때 view로
6
std::vector<folly::StringPiece> tokens;
7
folly::split(',', input, tokens);   // 0 alloc
8
// input이 살아 있는 범위에서만 사용

1
// 위험 — input이 함수 종료 시 사라짐
2
std::vector<folly::StringPiece> Tokenize() {
3
  std::string input = GetInput();
4
  std::vector<folly::StringPiece> v;
5
  folly::split(',', input, v);
6
  return v;   // input 소멸 → dangling
7
}
8

9
// 안전 — view와 owner 함께 반환
10
struct Tokens {
11
  std::string owner;
12
  std::vector<folly::StringPiece> view;
13
};