absl::StrJoin — 컨테이너 결합과 Formatter

1
// 회피 — 매 iteration alloc + 마지막 구분자 처리
2
std::string r;
3
for (size_t i = 0; i < parts.size(); ++i) {
4
  if (i > 0) r += ",";
5
  r += parts[i];
6
}

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

3
namespace absl {
4
template <typename Container>
5
std::string StrJoin(const Container& c, string_view sep);
6

7
template <typename Container, typename Formatter>
8
std::string StrJoin(const Container& c, string_view sep, Formatter f);
9

10
template <typename Iter>
11
std::string StrJoin(Iter first, Iter last, string_view sep);
12
}

1
std::vector<std::string> v = {"a","b","c"};
2
std::string s = absl::StrJoin(v, ", ");          // "a, b, c"
3

4
std::vector<int> ns = {1,2,3};
5
std::string s2 = absl::StrJoin(ns, "-");          // "1-2-3" (AlphaNum)
6

7
std::set<int> uniq = {3,1,4,1,5};
8
std::string s3 = absl::StrJoin(uniq, ",");        // "1,3,4,5" (정렬)
9

10
int arr[] = {10,20,30};
11
std::string s4 = absl::StrJoin(arr, "|");         // "10|20|30"

1
struct User { int64_t id; std::string name; };
2
std::vector<User> users = {{1,"Alice"}, {2,"Bob"}};
3

4
std::string s = absl::StrJoin(users, ", ",
5
    [](std::string* out, const User& u) {
6
      absl::StrAppend(out, u.name, "(", u.id, ")");
7
    });
8
// "Alice(1), Bob(2)"

1
absl::AlphaNumFormatter()      // 기본 (생략 시 사용)
2
absl::PairFormatter("=")       // pair를 "k=v" 형식으로
3
absl::DereferenceFormatter()   // 포인터/optional 역참조
4
absl::StreamFormatter()        // ostream operator<< 호출

1
// map → "k1=v1, k2=v2"
2
absl::flat_hash_map<std::string,int> m = {{"a",1},{"b",2}};
3
std::string s = absl::StrJoin(m, ", ", absl::PairFormatter("="));
4

5
// 포인터 컨테이너
6
std::vector<std::unique_ptr<User>> ptrs = /*...*/;
7
std::string s2 = absl::StrJoin(ptrs, ", ", absl::DereferenceFormatter(
8
    [](std::string* out, const User& u) {
9
      absl::StrAppend(out, u.name);
10
    }));

1
// absl/strings/str_join.h (요약)
2
template <typename Container, typename Formatter>
3
std::string JoinAlgorithm(const Container& c, string_view sep, Formatter f) {
4
  std::string result;
5
  auto it = c.begin();
6
  if (it != c.end()) {
7
    f(&result, *it);
8
    ++it;
9
    for (; it != c.end(); ++it) {
10
      result.append(sep.data(), sep.size());
11
      f(&result, *it);
12
    }
13
  }
14
  return result;
15
}

1
// 회피
2
std::string ids;
3
for (size_t i = 0; i < users.size(); ++i) {
4
  if (i > 0) ids += ",";
5
  ids += absl::StrCat(users[i].id);
6
}
7

8
// Good
9
std::string ids = absl::StrJoin(users, ",",
10
    [](std::string* out, const User& u) {
11
      absl::StrAppend(out, u.id);
12
    });

1
std::string clause = absl::StrCat(
2
    "WHERE user_id IN (",
3
    absl::StrJoin(user_ids, ","),
4
    ")");

1
auto quote = [](std::string* out, const std::string& s) {
2
  absl::StrAppend(out, "'", s, "'");  // 실제 SQL은 escape 필요
3
};
4
absl::StrJoin(names, ",", quote);

1
absl::flat_hash_map<std::string, std::string> params = {/*...*/};
2
std::string q = absl::StrJoin(params, "&",
3
    [](std::string* out, const auto& kv) {
4
      absl::StrAppend(out, kv.first, "=", kv.second);
5
    });

1
// 회피 — 매 호출 alloc
2
auto bad = [](const User& u) -> std::string {
3
  return absl::StrCat(u.name, "(", u.id, ")");
4
};
5
absl::StrJoin(users, ", ", [&](std::string* out, const User& u) {
6
  *out += bad(u);  // 임시 string alloc
7
});
8

9
// Good
10
auto good = [](std::string* out, const User& u) {
11
  absl::StrAppend(out, u.name, "(", u.id, ")");
12
};