为什么不将字符串文字作为对数组的引用而不是不透明的指针传递？

Question

在 C++ 中，字符串字面量的类型是 const char [N]，其中 N，如 std::size_t，是字符数加一（零字节终止符）。它们驻留在静态存储中，从程序初始化到终止都可用。

通常，采用常量字符串的函数不需要std::basic_string 的接口，或者更愿意避免动态分配；例如，他们可能只需要字符串本身及其长度。 std::basic_string 特别是必须提供一种从语言的本机字符串文字构造的方法。此类函数提供了一个采用 C 风格字符串的变体：

void function_that_takes_a_constant_string ( const char * /*const*/ s );

// Array-to-pointer decay happens, and takes away the string's length
function_that_takes_a_constant_string( "Hello, World!" );

正如this answer 中所解释的，数组衰减为指针，但它们的维度被带走了。在字符串文字的情况下，这意味着它们的长度（在编译时已知）会丢失，并且必须在 运行时通过遍历指向的内存直到找到零字节来重新计算。这不是最优的。

但是，字符串字面量，通常是数组，可以使用模板参数推导作为引用传递以保持其大小：

template<std::size_t N>
void function_that_takes_a_constant_string ( const char (& s)[N] );

// Transparent, and the string's length is kept
function_that_takes_a_constant_string( "Hello, World!" );

模板函数可以作为另一个函数的代理，真正的函数，它将接受一个指向字符串及其长度的指针，从而避免代码暴露并保持长度。

// Calling the wrapped function directly would be cumbersome.
// This wrapper is transparent and preserves the string's length.
template<std::size_t N> inline auto
function_that_takes_a_constant_string
( const char (& s)[N] )
{
    // `s` decays to a pointer
    // `N-1` is the length of the string
    return function_that_takes_a_constant_string_private_impl( s , N-1 );
}

// Isn't everyone happy now?
function_that_takes_a_constant_string( "Hello, World!" );

为什么不更广泛地使用它？特别是，为什么std::basic_string 没有带有建议签名的构造函数？

---

注意：我不知道建议的参数是如何命名的；如果您知道如何，请建议问题标题的版本。

Answer 1

从某种意义上说，这主要是历史性的。虽然您是正确的，但没有真正的理由不能这样做（如果您不想使用整个缓冲区，请传递一个长度参数，对吗？）如果您有一个字符数组，它仍然是正确的 通常一个缓冲区，不是你在任何时候都在使用的：

char buf[MAX_LEN];

由于这是通常它们的使用方式，因此为@987654323 添加新的basic_string 构造函数模板似乎没有必要甚至冒险 @。

不过，整个事情都非常边缘化。

Answer 2

添加这样一个模板化重载的问题很简单：

每当使用char-type 的静态缓冲区调用函数时都会使用它，即使缓冲区作为一个整体不是一个字符串，并且您真的只想传递初始字符串（嵌入零远不如终止零常见，并且使用缓冲区的一部分很常见）：当前代码很少包含从数组到指向 first 的指针的显式衰减元素，使用强制转换或函数调用。

演示代码(On coliru):

#include <stdio.h>
#include <string.h>

auto f(const char* s, size_t n) {
    printf("char* size_t %u\n", (unsigned)n);
    (void)s;
}
auto f(const char* s) {
    printf("char*\n");
    return f(s, strlen(s));
}
template<size_t N> inline auto
f( const char (& s)[N] ) {
    printf("char[&u]\n");
    return f(s, N-1);
}

int main() {
    char buffer[] = "Hello World";
    f(buffer);
    f(+buffer);
    buffer[5] = 0;
    f(buffer);
    f(+buffer);
}

记住：如果你在 C 中谈论一个字符串，它总是表示一个以 0 结尾的字符串，而在 C++ 中它也可以表示一个 std::string，这是计数的。

Answer 3

我相信这在 C++14 中基于用户定义的字符串文字得到解决

http://en.cppreference.com/w/cpp/string/basic_string/operator%22%22s

#include <string>

int main()
{
    //no need to write 'using namespace std::literals::string_literals'
    using namespace std::string_literals;

    std::string s2 = "abc\0\0def"; // forms the string "abc"
    std::string s1 = "abc\0\0def"s; // form the string "abc\0\0def"
}

Answer 4

您可以创建帮助类来解决这个问题，而无需对每个函数都使用重载

struct string_view
{
    const char* ptr;
    size_t size;
    template<size_t N>
    string_view(const char (&s)[N])
    {
        ptr = s;
        size = N;
    }
    string_view(const std::string& s)
    {
        ptr = s.data();
        size = s.size() + 1; // for '\0' at end
    }
};
void f(string_view);
main()
{
    string_view s { "Hello world!" };
    f("test");
}

您应该将此类扩展为辅助函数（如begine 和end）以简化程序中的使用。