absl::StrCat — 가변 인자 문자열 연결과 AlphaNum

1
// 회피
2
std::string r = a + b + c + d;
3
// 실제: ((a + b) + c) + d
4
// alloc 1: a+b → temp1
5
// alloc 2: temp1+c → temp2
6
// alloc 3: temp2+d → r

1
#include "absl/strings/str_cat.h"
2

3
namespace absl {
4
template <typename... AV>
5
std::string StrCat(const AV&... args);
6

7
template <typename... AV>
8
void StrAppend(std::string* dest, const AV&... args);
9
}

1
std::string s = absl::StrCat("user=", user_id, " action=", action);
2
// "user=42 action=login"
3

4
absl::StrAppend(&buf, " ", key, "=", value);

1
absl::StrCat(absl::Hex(255));                      // "ff"
2
absl::StrCat(absl::Hex(255, absl::kZeroPad4));     // "00ff"
3
absl::StrCat(absl::Hex(0xff, absl::kSpacePad6));   // "    ff"
4
absl::StrCat(absl::SixDigits(3.141592653589));     // "3.14159"

1
// absl/strings/str_cat.h (요약)
2
class AlphaNum {
3
  string_view piece_;
4
  char digits_[kFastToBufferSize];  // 정수/부동소수점 stringify 버퍼
5

6
 public:
7
  AlphaNum(int x);
8
  AlphaNum(int64_t x);
9
  AlphaNum(double f);
10
  AlphaNum(absl::string_view sv) : piece_(sv) {}
11
  AlphaNum(const std::string& s) : piece_(s) {}
12
  AlphaNum(const char* c) : piece_(c) {}
13
  AlphaNum(Hex hex);
14
  // ...
15

16
  string_view Piece() const { return piece_; }
17
  size_t size() const { return piece_.size(); }
18
};

1
// absl/strings/str_cat.cc (요약)
2
std::string CatPieces(std::initializer_list<string_view> pieces) {
3
  // 1) 합계 길이 계산
4
  size_t total = 0;
5
  for (string_view p : pieces) total += p.size();
6

7
  // 2) 한 번에 reserve
8
  std::string result;
9
  STLStringResizeUninitialized(&result, total);
10

11
  // 3) 순차 memcpy
12
  char* dst = &*result.begin();
13
  for (string_view p : pieces) {
14
    if (!p.empty()) memcpy(dst, p.data(), p.size());
15
    dst += p.size();
16
  }
17
  return result;
18
}
19

20
template <typename... AV>
21
std::string StrCat(const AV&... args) {
22
  // 각 args를 AlphaNum으로 감싸 Piece()를 추출
23
  return CatPieces({static_cast<const AlphaNum&>(args).Piece()...});
24
}

1
operator+        ~ 380 ns
2
ostringstream    ~ 270 ns
3
StrCat           ~  85 ns

1
std::string log_line = "[INFO] ";
2
absl::StrAppend(&log_line, "user=", user_id, " action=", action);

1
// 회피 — 매 라인마다 alloc
2
for (const auto& e : entries) {
3
  buf = buf + Format(e) + "\n";
4
}
5

6
// Good — 기존 buf 확장
7
for (const auto& e : entries) {
8
  absl::StrAppend(&buf, Format(e), "\n");
9
}

1
std::string s = "abc";
2

3
// 회피 — UB
4
s = absl::StrCat(s, "def", s);
5
// StrCat의 첫 인자에 들어간 `s`의 view가
6
// 결과 alloc 중 무효화될 수 있음
7

8
// Good — StrAppend
9
absl::StrAppend(&s, "def", s);  // 이쪽도 위험 — Abseil 문서가 금지
10
// 정말 자기 자신을 추가하려면 임시 변수
11
std::string tmp = s;
12
absl::StrAppend(&s, "def", tmp);

1
// 회피 — operator<< 호출이 매번 발생, 임시 stringstream
2
LOG(INFO) << "user=" << id << " ip=" << ip << " ms=" << ms;
3

4
// Good
5
LOG(INFO) << absl::StrCat("user=", id, " ip=", ip, " ms=", ms);

1
// 회피
2
std::string s = std::to_string(n);  // alloc + format
3

4
// Good (동일 alloc, 더 빠른 코드 경로)
5
std::string s = absl::StrCat(n);

1
return absl::InvalidArgumentError(
2
    absl::StrCat("Expected ", expected, " got ", actual));

1
// 회피
2
absl::StrCat(a, b, c, ..., z, aa);  // 컴파일 에러
3

4
// Good
5
std::string r = absl::StrCat(a, b, c, ..., z);
6
absl::StrAppend(&r, aa);