C++ 使用在编译时确定的字符串文字长度值

Question

Is the following a reasonable approach? Is there even a simpler way to avoid strlen() calls at runtime while keeping global constants defined as const char* const? I'm on C++17.

constexpr auto PREFIX = "myprefix";

std::string addPrefix(const std::string& s)
{
    static constexpr std::string_view prefix(PREFIX);
    std::string buf;
    buf.reserve(s.size() + prefix.size());
    buf += prefix;
    buf += s;
    return buf;
}

Answer 1

Yes, your code is performant. You can paste it into Compiler Explorer, with optimization flags, to see the result. The string_view will be done at compile time, and the length will be known at compile time so it doesn't do the counting off of strlen .

Is there a simpler way? Yes, but essentially the same thing just packaged to be reusable. I have (as do big libraries such as absil) an append function that takes any number of arguments, and does just that: adds up the lengths first, reserves, then copies.

A constexpr string_view is a very understandable way to get the length at compile-time, and it is generally good at replacing raw character literals because you get all the string class members on it etc, and you don't get distracted by the allocation for the trailing \0 . A more "minimal" way won't be any faster (after all, it's being done at compile time) and you have a separation between the string pointer and the length rather than encapsulating them, and you use an odd rare technique instead of this general one. So, just use this. It's good.

update

As Jarod42 points out, PREFIX as you defined it has type const char* . To clarify, the lexical string literal "myprefix" has type const char[9] . But the way you used auto it decays to a pointer. Even so, the constexpr constructor for string_view takes a const char* and scans for the terminating \0 , so having the length of the array does not help (you could have a nul in the middle of the array).

You should declare constant lexical string literals like this:

constexpr char s1[] = "the letters";

because it directly names the array of characters. If you write:

constexpr const char* s2 = "more letters";

you end up with another chunk of memory to represent the pointer, which is what gets named s2 , in addition to the actual array of characters.

Your use of auto is the same as s2 .