直接写入 std::string 的 char* 缓冲区
Directly write into char* buffer of std::string
所以我有一个 std::string 和一个接受 char* 并写入其中的函数。由于 std::string::c_str() 和 std::string::data() return const char*，我无法使用它们。所以我正在分配一个临时缓冲区，用它调用一个函数并将它复制到 std::string.
现在我打算处理大量信息，复制此缓冲区会产生明显的影响，我想避免它。
有些人建议使用 &str.front() 或 &str[0] 但它会调用未定义的行为吗？
C++98/03
不可能。字符串可以在写入时复制，因此它需要处理所有读取和写入。
C++11/14
在[string.require]中：
The char-like objects in a basic_string object shall be stored contiguously. That is, for any basic_string
object s, the identity &*(s.begin() + n) == &*s.begin() + n shall hold for all values of n such that 0 <= n < s.size().
所以 &str.front() 和 &str[0] 应该可以工作。
C++17
str.data()、&str.front() 和 &str[0] 有效。
Here 它说：
charT* data() noexcept;
Returns: A pointer p such that p + i == &operator[](i) for each i in [0, size()].
Complexity: Constant time.
Requires: The program shall not alter the value stored at p + size().
非常量 .data() 正常工作。
recent draft 对 .front() 的表述如下：
const charT& front() const;
charT& front();
Requires: !empty().
Effects: Equivalent to operator[](0).
以及 operator[] 的以下内容：
const_reference operator[](size_type pos) const;
reference operator[](size_type pos);
Requires: pos <= size().
Returns: *(begin() + pos) if pos < size(). Otherwise, returns a reference to an object of type charT with value charT(), where modifying the object leads to undefined behavior.
Throws: Nothing.
Complexity: Constant time.
所以它使用迭代器算法。所以我们需要检查有关迭代器的信息。 Here 它说：
3 A basic_string is a contiguous container ([container.requirements.general]).
所以我们需要去 here:
A contiguous container is a container that supports random access iterators ([random.access.iterators]) and whose member types iterator and const_iterator are contiguous iterators ([iterator.requirements.general]).
然后here:
Iterators that further satisfy the requirement that, for integral values n and dereferenceable iterator values a and (a + n), *(a + n) is equivalent to *(addressof(*a) + n), are called contiguous iterators.
显然，连续迭代器是 these papers 中添加的 C++17 功能。
需求可以改写为：
assert(*(a + n) == *(&*a + n));
因此，在第二部分中，我们取消引用迭代器，然后获取它指向的值的地址，然后对其进行指针运算，取消引用它，这与递增迭代器然后取消引用它相同。这意味着连续迭代器指向每个值紧接着另一个存储的内存，因此是连续的。由于采用 char* 的函数需要连续内存，因此您可以将 &str.front() 或 &str[0] 的结果传递给这些函数。
您可以简单地使用 &s[0] 作为 non-empty 字符串。这为您提供了指向缓冲区开头的指针
当你用它来放置 n 个字符的字符串时，string 的长度（不仅仅是容量）至少需要 n 之前，因为没有办法在不破坏数据的情况下进行调整。
也就是说，用法可以是这样的：
auto foo( int const n )
-> string
{
if( n <= 0 ) { return ""; }
string result( n, '#' ); // # is an arbitrary fill character.
int const n_stored = some_api_function( &result[0], n );
assert( n_stored <= n );
result.resize( n_stored );
return result;
}
这种方法从 C++11 开始就正式起作用了。在此之前，在 C++98 和 C++03 中，缓冲区并没有被正式保证是连续的。然而，对于 in-practice，该方法自第一个标准 C++98 以来一直有效——连续缓冲区要求可以在 C++11 中采用的原因（它是在 Lillehammer 会议上添加的，我认为是 2005 年）是没有现存的带有 non-contiguous 字符串缓冲区的标准库实现。
关于
” C++17 added added non-const data() to std::string but it still says that you can't modify the buffer.
我不知道有任何这样的措辞，因为那会破坏 non-const data() 的目的，我怀疑这个说法是否正确。
关于
” Now I plan to work with big amount of information and copying this buffer will have a noticeable impact and I want to avoid it.
如果复制缓冲区有明显的影响，那么您要避免无意中复制 std::string。
一种方法是将其包装在不可复制的 class 中。
我不知道你打算用那个做什么string，但是如果
您所需要的只是一个字符缓冲区，它会自动释放自己的内存，
然后我通常使用 vector<char> 或 vector<int> 或任何类型
您需要的缓冲区。
以v为向量，保证&v[0]指向
可以用作缓冲区的顺序内存。
注意：如果您认为 string::front() 与 &string[0] 相同，那么以下是多余的答案：
根据 cplusplus：在 C++98 中，您不应写入 .data() 或 .c_str()，它们将被视为 read-only/const :
A program shall not alter any of the characters in this sequence.
但是在 C++11 中这个警告被移除了，但是 return 值仍然是 const，所以正式地在 C++11 中也是不允许的。所以为了避免未定义的行为，你可以使用 string::front()，其中：
If the string object is const-qualified, the function returns a const char&. Otherwise, it returns a char&.
因此，如果您的字符串不是 const，那么正式允许您操作 return 由 string::front() 编辑的内容，这是对缓冲区第一个元素的引用。但是 link 没有提到这适用于哪个 C++ 标准。我假设 C++11 及更高版本。
此外，它 return 是第一个元素，而不是指针，因此您需要获取它的地址。目前尚不清楚您是否被正式允许将其用作整个缓冲区的 const char* ，但结合其他答案，我确信它是安全的。至少它不会产生任何编译器警告。
所以我有一个 std::string 和一个接受 char* 并写入其中的函数。由于 std::string::c_str() 和 std::string::data() return const char*，我无法使用它们。所以我正在分配一个临时缓冲区，用它调用一个函数并将它复制到 std::string.
现在我打算处理大量信息，复制此缓冲区会产生明显的影响，我想避免它。
有些人建议使用 &str.front() 或 &str[0] 但它会调用未定义的行为吗？
C++98/03
不可能。字符串可以在写入时复制，因此它需要处理所有读取和写入。
C++11/14
在[string.require]中：
The char-like objects in a
basic_stringobject shall be stored contiguously. That is, for anybasic_stringobjects, the identity&*(s.begin() + n) == &*s.begin() + nshall hold for all values ofnsuch that0 <= n < s.size().
所以 &str.front() 和 &str[0] 应该可以工作。
C++17
str.data()、&str.front() 和 &str[0] 有效。
Here 它说：
charT* data() noexcept;Returns: A pointer
psuch thatp + i == &operator[](i)for eachiin[0, size()].Complexity: Constant time.
Requires: The program shall not alter the value stored
at p + size().
非常量 .data() 正常工作。
recent draft 对 .front() 的表述如下：
const charT& front() const;
charT& front();Requires:
!empty().Effects: Equivalent to
operator[](0).
以及 operator[] 的以下内容：
const_reference operator[](size_type pos) const;
reference operator[](size_type pos);Requires:
pos <= size().Returns:
*(begin() + pos) if pos < size(). Otherwise, returns a reference to an object of typecharTwith valuecharT(), where modifying the object leads to undefined behavior.Throws: Nothing.
Complexity: Constant time.
所以它使用迭代器算法。所以我们需要检查有关迭代器的信息。 Here 它说：
3 A basic_string is a contiguous container ([container.requirements.general]).
所以我们需要去 here:
A contiguous container is a container that supports random access iterators ([random.access.iterators]) and whose member types
iteratorandconst_iteratorare contiguous iterators ([iterator.requirements.general]).
然后here:
Iterators that further satisfy the requirement that, for integral values n and dereferenceable iterator values
aand(a + n),*(a + n)is equivalent to*(addressof(*a) + n), are called contiguous iterators.
显然，连续迭代器是 these papers 中添加的 C++17 功能。
需求可以改写为：
assert(*(a + n) == *(&*a + n));
因此，在第二部分中，我们取消引用迭代器，然后获取它指向的值的地址，然后对其进行指针运算，取消引用它，这与递增迭代器然后取消引用它相同。这意味着连续迭代器指向每个值紧接着另一个存储的内存，因此是连续的。由于采用 char* 的函数需要连续内存，因此您可以将 &str.front() 或 &str[0] 的结果传递给这些函数。
您可以简单地使用 &s[0] 作为 non-empty 字符串。这为您提供了指向缓冲区开头的指针
当你用它来放置 n 个字符的字符串时，string 的长度（不仅仅是容量）至少需要 n 之前，因为没有办法在不破坏数据的情况下进行调整。
也就是说，用法可以是这样的：
auto foo( int const n )
-> string
{
if( n <= 0 ) { return ""; }
string result( n, '#' ); // # is an arbitrary fill character.
int const n_stored = some_api_function( &result[0], n );
assert( n_stored <= n );
result.resize( n_stored );
return result;
}
这种方法从 C++11 开始就正式起作用了。在此之前，在 C++98 和 C++03 中，缓冲区并没有被正式保证是连续的。然而，对于 in-practice，该方法自第一个标准 C++98 以来一直有效——连续缓冲区要求可以在 C++11 中采用的原因（它是在 Lillehammer 会议上添加的，我认为是 2005 年）是没有现存的带有 non-contiguous 字符串缓冲区的标准库实现。
关于
” C++17 added added non-const
data()tostd::stringbut it still says that you can't modify the buffer.
我不知道有任何这样的措辞，因为那会破坏 non-const data() 的目的，我怀疑这个说法是否正确。
关于
” Now I plan to work with big amount of information and copying this buffer will have a noticeable impact and I want to avoid it.
如果复制缓冲区有明显的影响，那么您要避免无意中复制 std::string。
一种方法是将其包装在不可复制的 class 中。
我不知道你打算用那个做什么string，但是如果
您所需要的只是一个字符缓冲区，它会自动释放自己的内存，
然后我通常使用 vector<char> 或 vector<int> 或任何类型
您需要的缓冲区。
以v为向量，保证&v[0]指向
可以用作缓冲区的顺序内存。
注意：如果您认为 string::front() 与 &string[0] 相同，那么以下是多余的答案：
根据 cplusplus：在 C++98 中，您不应写入 .data() 或 .c_str()，它们将被视为 read-only/const :
A program shall not alter any of the characters in this sequence.
但是在 C++11 中这个警告被移除了，但是 return 值仍然是 const，所以正式地在 C++11 中也是不允许的。所以为了避免未定义的行为，你可以使用 string::front()，其中：
If the string object is const-qualified, the function returns a const char&. Otherwise, it returns a char&.
因此，如果您的字符串不是 const，那么正式允许您操作 return 由 string::front() 编辑的内容，这是对缓冲区第一个元素的引用。但是 link 没有提到这适用于哪个 C++ 标准。我假设 C++11 及更高版本。
此外，它 return 是第一个元素，而不是指针，因此您需要获取它的地址。目前尚不清楚您是否被正式允许将其用作整个缓冲区的 const char* ，但结合其他答案，我确信它是安全的。至少它不会产生任何编译器警告。