C++ string handling

The std::string 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 "hello" still denotes a NUL-terminated array of characters.[1]

Using C++ classes to implement a string type offers several benefits of automated memory management and a reduced risk of out-of-bounds accesses,[2] 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 (the first such implementation, 1983)[3] or the CString type in Microsoft's MFC.[4] While std::string standardized strings, legacy applications still commonly contain such custom string types and libraries may expect C-style strings, making it "virtually impossible" to avoid using multiple string types in C++ programs[1] and requiring programmers to decide on the desired string representation ahead of starting a project.[4]

In a 1991 retrospective on the history of C++, its inventor Bjarne Stroustrup called the lack of a standard string type (and some other standard types) in C++ 1.0 the worst mistake he made in its development; "the absence of those led to everybody re-inventing the wheel and to an unnecessary diversity in the most fundamental classes".[3]

string a = "hello!";
string b = a; // Copy constructor

The std::string 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. An std::string can be constructed from a C-style string, and a C-style string can also be obtained from one.[6]

The individual units making up the string are of type char, at least (and almost always) 8 bits each. In modern usage these are often not "characters", but parts of a multibyte character encoding such as UTF-8.

The copy-on-write strategy was deliberately allowed by the initial C++ Standard for std::string because it was deemed a useful optimization, and used by nearly all implementations.[6] However, there were mistakes, in particular the operator[] returned a non-const reference in order to make it easy to port C in-place string manipulations (such code often assumed one byte per character and thus this may not have been a good idea!) This allowed the following code that shows that it must make a copy even though it is almost always used only to examine the string and not modify it:[7][8]

  std::string original("aaaaaaa");
  std::string string_copy = original; // make a copy
  char* pointer = &string_copy[3]; // some tried to make operator[] return a "trick" class but this makes it complex
  arbitrary_code_here(); // no optimizations can fix this
  *pointer = 'b'; // if operator[] did not copy, this would change original unexpectedly

This caused some implementations to abandon copy-on-write. 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[9] (especially for strings smaller than the size of a pointer). The optimization was finally disallowed in C++11,[7] with the result that even passing a std::string as an argument to a function, viz.

void print(std::string s) { std::cout << s; }

must be expected to perform a full copy of the string into newly allocated memory. The common idiom to avoid such copying is to pass as a const reference:

void print(const std::string& s) { std::cout << s; }

In C++17 added a new string_view class[10] that is only a pointer and length to read-only data, makes passing arguments far faster than either of the above examples:

void print(std::string_view s) { std::cout << s; }
...
  std::string x = ...;
  print(x); // does not copy x.data()
  print("this is a literal string"); // also does not copy the characters!
...

#include <iostream>
#include <string>
int main()
{
    std::string foo("fighters");
    std::string bar("stool");
    if (foo != bar)
        std::cout << "The strings are different." << std::endl;
    std::cout << "String = " << bar << std::endl;
    return 0;
}

typedef basic_string<char> string;