Folly Code Review · 36/89

folly::FixedString — compile-time string

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

cpp folly container fixedstring constexpr

#한 줄 요약

folly::FixedString<N>은 N 크기의 char 배열을 가진 fully constexpr 문자열. heap 없음, throw 없음, 모든 연산이 constexpr. compile-time string concat과 hash 계산이 가능.

#동기

C++의 string handling은 runtime이 default다. std::string은 heap, std::string_view는 view만, const char*는 길이 정보 없음. compile-time에 다음을 하고 싶다.

enum to string compile-time conversion.
log tag concatenation "[module=" + name + "]".
constexpr hash key.
table lookup의 key를 constexpr 생성.

C++17의 std::string_view는 view, C++20의 consteval은 표현력, C++26의 constexpr std::string은 아직 미정. 이 빈자리를 FixedString이 채운다.

1
constexpr auto tag = folly::makeFixedString("hello") +
2
                     folly::makeFixedString(", world");
3
// tag는 컴파일 타임에 "hello, world"
4
static_assert(tag.size() == 12);

#API & 사용법

1
#include <folly/FixedString.h>
2

3
// 1. 생성 — N은 컴파일 타임
4
constexpr folly::FixedString<5> s1{"hello"};
5
constexpr auto s2 = folly::makeFixedString("world");  // 추론
6

7
// 2. 표준 string 인터페이스
8
constexpr auto len = s1.size();             // 5
9
constexpr char c = s1[0];                   // 'h'
10
constexpr bool b = s1.starts_with("he");    // true
11

12
// 3. 연산 — 모두 constexpr
13
constexpr auto greeting = s1 + ", " + s2;
14
constexpr auto substr   = greeting.substr(0, 5);   // "hello"
15

16
// 4. string_view로 변환 (런타임에)
17
folly::StringPiece sp = s1;
18
std::string_view sv = s1;
19

20
// 5. compile-time hash
21
constexpr auto h = folly::FixedString{"key"}.hash();

FixedString<N>은 정확히 N+1 char buffer를 가진다(null terminator 포함). 모든 길이 정보가 type에 들어 있어 더 작은 객체.

#내부 구현

1
// 약식 — folly/FixedString.h
2
template <size_t N>
3
class BasicFixedString {
4
  char  data_[N + 1];   // null terminator 위해 +1
5
  size_t size_;
6

7
public:
8
  constexpr BasicFixedString() : data_{}, size_(0) {}
9

10
  constexpr BasicFixedString(const char (&s)[N + 1])
11
      : data_{}, size_(N) {
12
    for (size_t i = 0; i < N; ++i) data_[i] = s[i];
13
    data_[N] = '\0';
14
  }
15

16
  constexpr size_t size() const { return size_; }
17
  constexpr const char* data() const { return data_; }
18
  constexpr const char* c_str() const { return data_; }
19
  // ...
20
};
21

22
template <size_t N>
23
using FixedString = BasicFixedString<N>;

data_는 stack/static 영역. heap 호출 없음. constexpr context에서는 컴파일러가 buffer를 실제로 만들고 character를 채워 둔다.

#Operator+의 reductio

1
template <size_t M, size_t N>
2
constexpr BasicFixedString<M + N> operator+(
3
    const BasicFixedString<M>& a,
4
    const BasicFixedString<N>& b) {
5
  BasicFixedString<M + N> r;
6
  for (size_t i = 0; i < M; ++i) r.data_[i] = a.data_[i];
7
  for (size_t i = 0; i < N; ++i) r.data_[M + i] = b.data_[i];
8
  r.data_[M + N] = '\0';
9
  r.size_ = M + N;
10
  return r;
11
}

결과 타입의 N이 두 operand size 합. compile-time 산술로 결정.

#Compile-time hash

1
// 약식
2
constexpr uint64_t fnv1a(const char* s, size_t n) {
3
  uint64_t h = 0xcbf29ce484222325;
4
  for (size_t i = 0; i < n; ++i) {
5
    h ^= s[i];
6
    h *= 0x100000001b3;
7
  }
8
  return h;
9
}
10

11
template <size_t N>
12
constexpr uint64_t BasicFixedString<N>::hash() const {
13
  return fnv1a(data_, size_);
14
}

constexpr이므로 컴파일러가 hash 값을 미리 계산. switch (FixedString{"key"}.hash()) { case ... } 같은 코드가 동작.

#std/abseil 비교

1
// std (C++26 후보)
2
// constexpr std::string  — 아직 미확정
3

4
// 현재 std
5
constexpr std::string_view sv = "hello";   // view만
6
// 길이 정보는 있으나 storage 합성 불가
7

8
// abseil — 직접 대응 없음. CharSet 정도
9

10
// folly
11
constexpr folly::FixedString s = "hello";  // 완전 constexpr

C++20의 std::string_view는 view만이라 새 문자열 합성 불가. constexpr std::string은 표준 일정에 따라 다름. FixedString은 지금 compile-time 합성을 제공.

#사용 사례

#1. Enum to string

1
enum class Level { Info, Warning, Error };
2

3
constexpr auto levelName(Level l) {
4
  switch (l) {
5
    case Level::Info:    return folly::makeFixedString("INFO");
6
    case Level::Warning: return folly::makeFixedString("WARN");
7
    case Level::Error:   return folly::makeFixedString("ERR");
8
  }
9
}
10
// 호출도 constexpr 가능

#2. Log prefix concatenation

1
template <size_t N>
2
constexpr auto logPrefix(folly::FixedString<N> module) {
3
  return folly::makeFixedString("[mod=") + module + "] ";
4
}
5
constexpr auto prefix = logPrefix(folly::makeFixedString("net"));
6
// "[mod=net] "

#3. Compile-time map key

1
constexpr struct {
2
  folly::FixedString<8> name;
3
  int                   value;
4
} table[] = {
5
  { folly::makeFixedString("alpha"),   1 },
6
  { folly::makeFixedString("beta"),    2 },
7
  { folly::makeFixedString("gamma"),   3 },
8
};

#코드 리뷰 포인트

1
// Bad — runtime string을 FixedString으로
2
auto s = folly::makeFixedString(GetRuntimeString().c_str());
3
// N을 컴파일 타임에 알 수 없어 안 됨
4

5
// Good — runtime은 fbstring/string
6
folly::fbstring s = GetRuntimeString();

FixedString<N>의 N은 컴파일 타임 상수여야 한다. runtime 길이면 다른 type을 쓴다.

1
// 주의 — 큰 N은 객체 크기 증가
2
constexpr folly::FixedString<10000> buf;   // 10KB stack/object

FixedString<N>의 sizeof는 N+1+sizeof(size_t). 큰 N은 stack/static 메모리 압박.

#안티패턴

template parameter pack에 FixedString 잘못 사용: template argument에 사용하려면 C++20 consteval/constexpr이 잘 동작하는 컴파일러 필요. gcc 9+, clang 10+.
runtime string과 mix: folly::FixedString + std::string은 불가. 명시적 변환 후 연결.
N을 type 시그니처에 노출: 함수 인자 void f(FixedString<5>)은 오직 5-char만 받음. template 함수로 N 추론하게.