C++ 20 中的 constexpr std::string，它是如何工作的？

Question

显然，GCC 的 libstdc++ 还没有添加 constexpr std::string（从 GCC v11.2 开始）。

这段代码：

#include <iostream>
#include <string>


int main( )
{
    constexpr std::string str { "Where is the constexpr std::string support?"};

    std::cout << str << '\n';
}

无法编译：

time_measure.cpp:37:31: error: the type 'const string' {aka 'const std::__cxx11::basic_string<char>'} of 'constexpr' variable 'str' is not literal
   37 |         constexpr std::string str { "Where is the constexpr std::string support?"};
      |                               ^~~
In file included from c:\mingw64\include\c++\11.2.0\string:55,
                 from c:\mingw64\include\c++\11.2.0\bits\locale_classes.h:40,
                 from c:\mingw64\include\c++\11.2.0\bits\ios_base.h:41,
                 from c:\mingw64\include\c++\11.2.0\ios:42,
                 from c:\mingw64\include\c++\11.2.0\ostream:38,
                 from c:\mingw64\include\c++\11.2.0\iostream:39,
                 from time_measure.cpp:2:
c:\mingw64\include\c++\11.2.0\bits\basic_string.h:85:11: note: 'std::__cxx11::basic_string<char>' is not literal because:
   85 |     class basic_string
      |           ^~~~~~~~~~~~
c:\mingw64\include\c++\11.2.0\bits\basic_string.h:85:11: note:   'std::__cxx11::basic_string<char>' does not have 'constexpr' destructor

我的问题是，当字符串包含超过 16 个chars（因为 GCC 的 SSO 缓冲区大小为 16）时，这些字符串将如何在后台工作？有人可以给我一个简短的解释吗？ 一个简单的构造函数会在堆栈上创建字符串对象并且从不使用动态分配吗？

这段代码：

    std::cout << "is_trivially_constructible: "
              << std::boolalpha << std::is_trivially_constructible<const std::string>::value << '\n';

打印这个：

is_trivially_constructible: false

现在在这里使用constexpr（显然不能使用 GCC v11.2 编译）：

    std::cout << "is_trivially_constructible: "
              << std::boolalpha << std::is_trivially_constructible<constexpr std::string>::value << '\n';

结果会是true，如下所示吗？

is_trivially_constructible: true

我的目标

我的目标是做类似的事情：

    constexpr std::size_t a { 4 };
    constexpr std::size_t b { 5 };
    constexpr std::string msg { std::format( "{0} + {1} == {2}", a, b, a + b ) };

    std::cout << msg << '\n';

std::format 和 constexpr std::string 都不能在 GCC v11.2 上编译。

Answer 1

C++20 支持在 constexpr 时间内分配，只要分配在时间常数评估结束时完全解除分配。因此，例如，这个非常愚蠢的例子在 C++20 中是有效的：

constexpr int f() {
    int* p = new int(42);
    int v = *p;
    delete p;
    return v;
}

static_assert(f() == 42);

但是，如果你忘记了delete p;，那么f() 就不再是一个常量表达式。不能泄露内存。例如，gcc 拒绝：

<source>:2:24: error: '(f() == 42)' is not a constant expression because allocated storage has not been deallocated
    2 |     int* p = new int(42);
      |                        ^

---

回到你的问题，std::string 可以在constexpr 中正常工作——正如你所期望的那样为它分配内存。但是，C++20 constexpr 规则仍然受此规则的限制，即所有分配必须在评估结束时清理。或者说，所有分配都必须是 transient - C++ 尚不支持非瞬态 constexpr 分配。

因此，您的原始程序

int main( )
{
    constexpr std::string str { "Where is the constexpr std::string support?"};
}

无效，即使 gcc 支持 constexpr string（就像它现在在主干上所做的那样），因为 str 需要被销毁。不过这样就好了：

constexpr int f() {
    std::string s = "Where is the constexpr std::string support?";
    return s.size();
}

static_assert(f() > 16);

而它不会在 C++17 中编译。

---

在 C++23 中仍然不支持非瞬态 constexpr 分配。这是一个令人惊讶的棘手问题。但是，希望很快。