absl::string_view — non-owning 문자열 참조

1
// 회피
2
bool StartsWithBoo(const std::string& s);
3

4
// 호출 측에서 std::string 객체가 강제됨
5
StartsWithBoo("boom");            // 임시 string 객체 alloc + 복사
6
char c[] = "boom";
7
StartsWithBoo(c);                 // 임시 string 객체 alloc + 복사
8

9
absl::string_view sv = "boom";
10
StartsWithBoo(std::string(sv));   // 호출 측이 변환 비용을 지불

1
// Good
2
bool StartsWithBoo(absl::string_view s);
3

4
StartsWithBoo("boom");                       // alloc 없음
5
StartsWithBoo(std::string("boom"));          // alloc 없음 (std::string → view)
6
StartsWithBoo(absl::string_view("boom"));    // alloc 없음

1
namespace absl {
2
class string_view {
3
 public:
4
  // 생성
5
  constexpr string_view() noexcept;                       // 빈 view
6
  constexpr string_view(const char* data, size_t len);    // 명시 길이
7
  string_view(const char* str);                           // strlen
8
  string_view(const std::string& s) noexcept;             // 변환
9

10
  // 접근
11
  constexpr const char* data() const noexcept;
12
  constexpr size_t size() const noexcept;
13
  constexpr bool empty() const noexcept;
14
  constexpr char operator[](size_t i) const;
15

16
  // 잘라내기 (새 view 생성, alloc 없음)
17
  constexpr string_view substr(size_t pos, size_t n = npos) const;
18
  constexpr void remove_prefix(size_t n);
19
  constexpr void remove_suffix(size_t n);
20

21
  // 검색
22
  size_t find(string_view s, size_t pos = 0) const noexcept;
23
  size_t rfind(string_view s, size_t pos = npos) const noexcept;
24

25
  // 변환
26
  explicit operator std::string() const;  // alloc 발생
27
};
28
}

1
// std::string — 매 substr마다 alloc
2
std::string log = "2026-05-23T19:00:00 INFO ...";
3
std::string date = log.substr(0, 10);       // alloc
4
std::string level = log.substr(20, 4);      // alloc
5

6
// absl::string_view — alloc 0
7
absl::string_view log = "2026-05-23T19:00:00 INFO ...";
8
absl::string_view date = log.substr(0, 10);   // 포인터+길이만 갱신
9
absl::string_view level = log.substr(20, 4);

1
// absl/strings/string_view.h (요약)
2
class string_view {
3
  const char* ptr_;
4
  size_t length_;
5
 public:
6
  // ...
7
};

1
// 권장 — 값으로 받는다
2
void Parse(absl::string_view input);
3

4
// 회피 — 참조로 받을 이유가 없다 (이미 충분히 작다)
5
void Parse(const absl::string_view& input);

1
// absl/strings/string_view.h (요약)
2
#ifdef ABSL_USES_STD_STRING_VIEW
3
namespace absl {
4
using string_view = std::string_view;
5
}
6
#else
7
namespace absl {
8
class string_view { /* ... */ };
9
}
10
#endif

1
// 회피
2
absl::Status SaveUser(const std::string& name);
3

4
// Good
5
absl::Status SaveUser(absl::string_view name);

1
// 회피 (alloc 발생)
2
if (path.substr(0, 5) == "/api/") { ... }
3

4
// Good (alloc 없음)
5
absl::string_view path_view = path;
6
if (path_view.substr(0, 5) == "/api/") { ... }
7

8
// 더 Good
9
if (absl::StartsWith(path, "/api/")) { ... }

1
bool absl::StartsWith(absl::string_view s, absl::string_view prefix);
2
bool absl::EndsWith(absl::string_view s, absl::string_view suffix);
3
bool absl::StrContains(absl::string_view haystack, absl::string_view needle);

1
// 회피
2
class UserCache {
3
  absl::string_view user_name_;  // dangling 위험
4
 public:
5
  void SetName(absl::string_view name) { user_name_ = name; }
6
};
7

8
// Good — 보관할 거면 std::string으로
9
class UserCache {
10
  std::string user_name_;
11
 public:
12
  void SetName(absl::string_view name) { user_name_ = std::string(name); }
13
};

1
// 회피 — 컴파일 안 됨
2
open(view.c_str(), O_RDONLY);
3

4
// Good — 변환 비용 인지
5
open(std::string(view).c_str(), O_RDONLY);