diff --git a/defensive-coding/en-US/CXX-Std.xml b/defensive-coding/en-US/CXX-Std.xml
index 5ed53a4..181ad48 100644
--- a/defensive-coding/en-US/CXX-Std.xml
+++ b/defensive-coding/en-US/CXX-Std.xml
@@ -7,7 +7,84 @@
The C++ standard library includes most of its C counterpart
by reference, see .
-
+
+ String handling with <literal>std::string</literal>
+
+ The std::string class provides a convenient
+ way to handle strings. Unlike C strings,
+ std::string objects have an explicit length
+ (and can contain embedded NUL characters), and storage for its
+ characters is managed automatically. This section discusses
+ std::string, but these observations also
+ apply to other instances of the
+ std::basic_string template.
+
+
+ The pointer returned by the data() member
+ function does not necessarily point to a NUL-terminated string.
+ To obtain a C-compatible string pointer, use
+ c_str() instead, which adds the NUL
+ terminator.
+
+
+ The pointers returned by the data() and
+ c_str() functions and iterators are only
+ valid until certain events happen. It is required that the
+ exact std::string object still exists (even
+ if it was initially created as a copy of another string object).
+ Pointers and iterators are also invalidated when non-const
+ member functions are called, or functions with a non-const
+ reference parameter. The behavior of the GCC implementation
+ deviates from that required by the C++ standard if multiple
+ threads are present. In general, only the first call to a
+ non-const member function after a structural modification of the
+ string (such as appending a character) is invalidating, but this
+ also applies to member function such as the non-const version of
+ begin(), in violation of the C++ standard.
+
+
+ Particular care is necessary when invoking the
+ c_str() member function on a temporary
+ object. This is convenient for calling C functions, but the
+ pointer will turn invalid as soon as the temporary object is
+ destroyed, which generally happens when the outermost expression
+ enclosing the expression on which c_str()
+ is called completes evaluation. Passing the result of
+ c_str() to a function which does not store
+ or otherwise leak that pointer is safe, though.
+
+
+ Like with std::vector and
+ std::array, subscribing with
+ operator[] does not perform bounds checks.
+ Use the at(size_type) member function
+ instead. See .
+
+
+ Never write to the pointers returned by
+ data() or c_str()
+ after casting away const. If you need a
+ C-style writable string, use a
+ std::vector<char> object and its
+ data() member function. In this case, you
+ have to explicitly add the terminating NUL character.
+
+
+ GCC's implementation of std::string is
+ currently based on reference counting. It is expected that a
+ future version will remove the reference counting, due to
+ performance and conformance issues. As a result, code that
+ implicitly assumes sharing by holding to pointers or iterators
+ for too long will break, resulting in run-time crashes or worse.
+ On the other hand, non-const iterator-returning functions will
+ no longer give other threads an opportunity for invalidating
+ existing iterators and pointers because iterator invalidation
+ does not depend on sharing of the internal character array
+ object anymore.
+
+
+
Containers and <literal>operator[]</literal>
Many containers similar to std::vector