C++ string handling
The C++ programming language has support for string handling, mostly implemented in its standard library. The language standard specifies several string types, some inherited from C, some designed to make use of the language's features, such as classes and RAII. The most-used of these is, while is used for non-owning string views.
Since the initial versions of C++ had only the "low-level" C string handling functionality and conventions, multiple incompatible designs for string handling classes have been designed over the years and are still used instead of, and C++ programmers may need to handle multiple conventions in a single application.
History
The type is the main string datatype in standard C++ since 1998, but it was not always part of C++. From C, C++ inherited the convention of using null-terminated strings that are handled by a pointer to their first element, and a library of functions that manipulate such strings. In modern standard C++, a string literal such as still denotes a NUL-terminated array of characters.Using C++ classes to implement a string type offers several benefits of automated memory management and a reduced risk of out-of-bounds accesses, and more intuitive syntax for string comparison and concatenation. Therefore, it was strongly tempting to create such a class. Over the years, C++ application, library and framework developers produced their own, incompatible string representations, such as the one in AT&T's Standard Components library or the type in Microsoft's MFC or the in Qt.
The various vendors' string types have different implementation strategies and performance characteristics, which made conversion of code and even assignment from one to another difficult:
- Some used a copy-on-write strategy with major performance implications.
- Though most agreed on syntax for comparison, assignment, and concatenation; the syntax to extract substrings or perform searches varied widely.
- Not everything was Unicode, leading to widespread variations in how or if encoding was stored and when translation was done, and sometimes very expensive assignment operators. It was also believed code units larger than bytes were necessary to support Unicode, leading to string types that could not interoperate in any efficient manner.
Description
The class is the standard representation for a text string since C++98. The class provides some typical string operations like comparison, concatenation, find and replace, and a function for obtaining substrings. A can be constructed from a C-style string, and a C-style string can also be obtained from one. The individual units making up the string are of type. In modern usage these are often not "characters", but parts of a multibyte character encoding such as UTF-8.import std;
using std::string;
int main
Copy on Write
A copy-on-write implementation meansstring a = "hello!";
string b = a; // Copy constructor
does not actually copy the content of to ; instead, both strings share their contents and a reference count on the content is incremented. The actual copying is postponed until a mutating operation, such as appending a character to either string, makes the strings' contents differ.
The copy-on-write strategy was deliberately allowed by the initial C++ Standard for because it was deemed a useful optimization, and used by nearly all implementations. However, there were mistakes, in particular the returned a non-const reference in order to make it easy to port C code such as, and had to trigger a copy. Multi-threading caused even the optimization of not copying if the reference count was one to fail. It was also discovered that the overhead in multi-threaded applications due to the locking needed to examine or change the reference count was greater than the overhead of copying small strings on modern processors.
This caused implementations, first MSVC and later GCC, to move away from copy-on-write. The optimization was finally disallowed in C++11.
String views
Unlike in other languages, such as Java or C#, C++ strings are always mutable, as quoted null-terminated string constants served most of the purpose of a non-mutable class. C++ requires that the following code make a copy of the string, this is quite slow compared to passing a pointer, even if copy on write reference counts are used.import std;
using std::string;
void outputString
//...
string s = "...";
outputString; // makes a copy of s
outputString; // copies the string, sometimes twice
Though the compiler could optimize this away for inline functions, few relied on this and almost always strings are passed as a const reference: Conversion from a string constant also required constructing a temporary and was slow, usually leading to overloaded functions:
import std;
using std::string;
void outputString
void outputString
//...
string s = "...";
outputString; // does not copy s, passes a pointer/reference
outputString; // calls overload and passes raw pointer
The C++17 standard adds the class that is only a pointer and length to read-only data, and is a drop-in replacement for an immutable temporary and makes pass-by-value arguments faster than either of the above examples:
import std;
using std::string;
using std::string_view;
void outputString
//...
string s = "...";
outputString; // one less level of indirection
outputString; // furthermore compiler may optimize away need to use strlen
All functions in a library that take a string argument must be rewritten to take advantage of this in C++17, as conversion from to is still expensive.
Other code units
is a typedef for a particular instantiation of the template class. Its definition is found in the header:namespace std
Thus provides functionality for strings having elements of type. There is a similar class, which consists of, and is most often used to store UTF-16 text on Windows and UTF-32 on most Unix-like platforms. The C++ standard, however, does not impose any interpretation as Unicode code points or code units on these types and does not even guarantee that a holds more bits than a. To resolve some of the incompatibilities resulting from 's properties, C++11 added two new classes: and , which are the given number of bits per code unit on all platforms.
C++11 also added new string literals of 16-bit and 32-bit "characters" and syntax for putting Unicode code points into null-terminated strings.
A is guaranteed to be specializable for any type with a struct to accompany it. As of C++11, only,, and specializations are required to be implemented.
A is also a Standard Library container, and thus the Standard Library algorithms can be applied to the code units in strings.