由于问题在于非平凡析构函数，因此如果从std::string中删除析构函数，则可以定义该类型的constexpr实例。像这样

struct constexpr_str {
    char const* str;
    std::size_t size;

    // can only construct from a char[] literal
    template <std::size_t N>
    constexpr constexpr_str(char const (&s)[N])
        : str(s)
        , size(N - 1) // not count the trailing nul
    {}
};

int main()
{
    constexpr constexpr_str s("constString");

    // its .size is a constexpr
    std::array<int, s.size> a;
    return 0;
}

c++ 20将添加constexpr字符串和向量

下面的提议显然已经被接受了:http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0980r0.pdf，它增加了构造函数，比如:

// 20.3.2.2, construct/copy/destroy
constexpr
basic_string() noexcept(noexcept(Allocator())) : basic_string(Allocator()) { }
constexpr
explicit basic_string(const Allocator& a) noexcept;
constexpr
basic_string(const basic_string& str);
constexpr
basic_string(basic_string&& str) noexcept;

除了all / most方法的constexpr版本。

GCC 9.1.0版本不支持，编译失败:

#include <string>

int main() {
    constexpr std::string s("abc");
}

:

g++-9 -std=c++2a main.cpp

错误:

error: the type ‘const string’ {aka ‘const std::__cxx11::basic_string<char>’} of ‘constexpr’ variable ‘s’ is not literal

不能创建constexpr std::vector

在Ubuntu 19.04中测试。

由于问题在于非平凡析构函数，因此如果从std::string中删除析构函数，则可以定义该类型的constexpr实例。像这样

struct constexpr_str {
    char const* str;
    std::size_t size;

    // can only construct from a char[] literal
    template <std::size_t N>
    constexpr constexpr_str(char const (&s)[N])
        : str(s)
        , size(N - 1) // not count the trailing nul
    {}
};

int main()
{
    constexpr constexpr_str s("constString");

    // its .size is a constexpr
    std::array<int, s.size> a;
    return 0;
}

c++ 20朝着在编译时使用std::string迈进了一步，但是P0980将不允许你编写像你的问题中的代码:

constexpr std::string constString = "constString";

the reason is that constexpr std::string is allowed only to be used in constexpr function (constant expression evaluation context). Memory allocated by constexpr std::string must be freed before such function returns - this is the so called transient allocation, and this memory cannot 'leak' outside to runtime to constexpr objects (stored in data segments) accessible at runtime . For example compilation of above line of code in current VS2022 preview (cl version : 19.30.30704) results in following error:

1> : error C2131: expression did not evaluate to a constant
1> : message : (sub-)object points to memory which was heap allocated during constant evaluation

这是因为它试图进行不允许的非瞬态分配——这将意味着分配到已编译二进制文件的数据段中。

在p0784r1中，在“非瞬态分配”段落中，你可以发现有一个计划允许将瞬态内存转换为静态内存(强调我的):

在时间计算时还没有释放的存储怎么办 完成吗?我们可以不允许，但确实有 这可能是可取的令人信服的用例。例如，这可能 作为更灵活的“字符串字面值”类的基础。我们 因此，提出如果非瞬态constexpr分配为 有效的(下面将进行描述)，则将分配的对象提升为 静态存储持续时间。

有一种方法可以将暂态std::string数据导出到外部，使其在运行时可用。你必须复制它到std::array，问题是计算std::array的最终大小，你可以预设一些大的大小或计算std::string两次-一次得到大小，然后得到atual数据。以下代码成功编译并在当前VS2022预览5上运行。它基本上是用分隔符连接三个单词:

constexpr auto join_length(const std::vector<std::string>& vec, char delimiter) {
  std::size_t length = std::accumulate(vec.begin(), vec.end(), 0,
    [](std::size_t sum, const std::string& s) {
      return sum + s.size();
    });
  return length + vec.size();
}

template<size_t N>
constexpr std::array<char, N+1> join_to_array(const std::vector<std::string>& vec, char delimiter) {
  std::string result = std::accumulate(std::next(vec.begin()), vec.end(),
    vec[0],
    [&delimiter](const std::string& a, const std::string& b) {
      return a + delimiter + b;
    });
  std::array<char, N+1> arr = {};
  int i = 0;
  for (auto c : result) {
    arr[i++] = c;
  }
  return arr;
}
constexpr std::vector<std::string> getWords() {
  return { "one", "two", "three" };
}

int main()
{
  constexpr auto arr2 = join_to_array<join_length(getWords(), ';')>(getWords(), ';');
  static_assert(std::string(&arr2[0]) == "one;two;three");
  std::cout << &arr2[0] << "\n";
}

不，你的编译器已经给了你一个全面的解释。

但是你可以这样做:

constexpr char constString[] = "constString";

在运行时，当需要时，这可以用来构造std::string。

从c++ 20开始，是的，但前提是std::string在常量求值结束时被销毁。所以当你的例子仍然不能编译时，像这样的东西会:

constexpr std::size_t n = std::string("hello, world").size();

然而，从c++ 17开始，你可以使用string_view:

constexpr std::string_view sv = "hello, world";

string_view是一个类似字符串的对象，充当对任何char对象序列的不可变、非所有引用。