Directly write into char* buffer of std::string

by

C++98/03

Impossible. String can be copy on write so it needs to handle all reads and writes.

C++11/14

In [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().

So &str.front() and &str[0] should work.

C++17

str.data(), &str.front() and &str[0] work.

Here it says:

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().

The non-const .data() just works.

The recent draft has the following wording for .front():

const charT& front() const;

charT& front();

Requires: !empty().

Effects: Equivalent to operator[](0).

And the following for 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.

So it uses iterator arithmetic. so we need to inspect the information about iterators. Here it says:

3 A basic_string is a contiguous container ([container.requirements.general]).

So we need to go 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]).

Then 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.

Apparently, contiguous iterators are a C++17 feature which was added in these papers.

The requirement can be rewritten as:

assert(*(a + n) == *(&*a + n));

So, in the second part we dereference iterator, then take address of the value it points to, then do a pointer arithmetic on it, dereference it and it’s the same as incrementing an iterator and then dereferencing it. This means that contiguous iterator points to the memory where each value stored right after the other, hence contiguous. Since functions that take char* expect contiguous memory, you can pass the result of &str.front() or &str[0] to these functions.

More Related Contents:

  1. Is a pointer with the right address and type still always a valid pointer since C++17?
  2. Self-initialization of a static constexpr variable, is it well-formed?
  3. What changes to C++ made copy initialization work for class with explicit constructor?
  4. what is the concept of evaluation of expression z = (y = 30) + (y = 10) + (y = 20); [closed]
  5. Has C++ standard changed with respect to the use of indeterminate values and undefined behavior in C++14?
  6. reinterpret_cast creating a trivially default-constructible object
  7. Will std::string always be null-terminated in C++11?
  8. Is it a conforming compiler extension to treat non-constexpr standard library functions as constexpr?
  9. Strongly typed using and typedef
  10. static_assert dependent on non-type template parameter (different behavior on gcc and clang)
  11. Is stateful metaprogramming ill-formed (yet)?
  12. Deleted default constructor. Objects can still be created… sometimes
  13. How is P0522R0 breaking code?
  14. Try to understand compiler error message: default member initializer required before the end of its enclosing class
  15. structured bindings: when something looks like a reference and behaves similarly to a reference, but it’s not a reference
  16. std::ignore with structured bindings?
  17. Does the behavior of guaranteed copy elision depend on existence of user-defined copy constructor?
  18. Can std::launder be used to convert an object pointer to its enclosing array pointer?
  19. Static member access in constant expressions
  20. Compile-time or runtime detection within a constexpr function
  21. Pointer interconvertibility vs having the same address
  22. Why doesn’t an if constexpr make this core constant expression error disappear?
  23. Why was the space character not chosen for C++14 digit separators?
  24. Why isn’t `std::initializer_list` defined as a literal type?
  25. Is writing to &str[0] buffer (of a std:string) well-defined behaviour in C++11?
  26. Classes with both template and non-template conversion operators in the condition of switch statement
  27. Using std::string_view with api that expects null-terminated string
  28. Injected class name compiler discrepancy
  29. Will I be able to declare a constexpr lambda inside a template parameter?
  30. Can I use the result of a C++17 captureless lambda constexpr conversion operator as a function pointer template non-type argument?

Leave a Comment