Raw String Literals

Raw string literals are string literals that can span across multiple lines of code, that don’t require escaping of embedded double quotes, and where escape sequences like and are processed as normal text and not as escape sequences. Escape sequences are discussed in Chapter 1. For example, if you write the following with a normal string literal, you will get a compilation error because the string contains non-escaped double quotes:

const char* str = "Hello "World"!";    // Error!

Normally you have to escape the double quotes as follows:

const char* str = "Hello "World"!";

With a raw string literal, you can avoid the need to escape the quotes. The raw string literal starts with R"( and ends with )".

const char* str = R"(Hello "World"!)";

If you need a string consisting of multiple lines, without raw string literals you need to embed escape sequences in your string where you want to start a new line. For example:

const char* str = "Line 1
Line 2";

If you output this string to the console, you get the following:

Line 1
Line 2

With a raw string literal, instead of using escape sequences to start new lines, you can simply press enter to start real physical new lines in your source code as follows. The output is the same as the previous code snippet using the embedded .

const char* str = R"(Line 1
Line 2)";

Escape sequences are ignored in raw string literals. For example, in the following raw string literal, the escape sequence is not replaced with a tab character, but is kept as the sequence of a backslash followed by the letter t:

const char* str = R"(Is the following a tab character? 	)";

So, if you output this string to the console, you get:

Is the following a tab character? 	

Because a raw string literal ends with )" you cannot embed a )" in your string using this syntax. For example, the following string is not valid because it contains the )" sequence in the middle of the string:

const char* str = R"(Embedded )" characters)";    // Error!

If you need embedded )" characters, you need to use the extended raw string literal syntax, which is as follows:

R"d-char-sequence(r-char-sequence)d-char-sequence"

The r-char-sequence is the actual raw string. The d-char-sequence is an optional delimiter sequence, which should be the same at the beginning and at the end of the raw string literal. This delimiter sequence can have at most 16 characters. You should choose this delimiter sequence as a sequence that will not appear in the middle of your raw string literal.

The previous example can be rewritten using a unique delimiter sequence as follows:

const char* str = R"-(Embedded )" characters)-";

Raw string literals make it easier to work with database querying strings, regular expressions, file paths, and so on. Regular expressions are discussed in Chapter 19.

What Is Wrong with C-Style Strings?

To understand the necessity of the C++ string class, consider the advantages and disadvantages of C-style strings.

Advantages:

• They are simple, making use of the underlying basic character type and array structure.
• They are lightweight, taking up only the memory that they need if used properly.
• They are low level, so you can easily manipulate and copy them as raw memory.
• They are well understood by C programmers—why learn something new?

Disadvantages:

• They require incredible efforts to simulate a first-class string data type.
• They are unforgiving and susceptible to difficult-to-find memory bugs.
• They don’t leverage the object-oriented nature of C++.
• They require knowledge of their underlying representation on the part of the programmer.

The preceding lists were carefully constructed to make you think that perhaps there is a better way. As you’ll learn, C++ strings solve all the problems of C strings and render most of the arguments about the advantages of C strings over a first-class data type irrelevant.

Using the string Class

Even though string is a class, you can almost always treat it as if it were a built-in type. In fact, the more you think of it that way, the better off you are. Through the magic of operator overloading, C++ strings are much easier to use than C-style strings. For example, the + operator is redefined for strings to mean “string concatenation.” The following code produces 1234:

string A("12");
string B("34");
string C;
C = A + B;    // C is "1234"

The += operator is also overloaded to allow you to easily append a string:

string A("12");
string B("34");
A += B;    // A is "1234"

Another problem with C strings is that you cannot use == to compare them. Suppose you have the following two strings:

char* a = "12";
char b[] = "12";

Writing a comparison as follows always returns false, because it compares the pointer values, not the contents of the strings:

if (a == b)

Note that C arrays and pointers are related. You can think of C arrays, like the b array in the example, as pointers to the first element in the array. Chapter 7 goes deeper in on the array-pointer duality.

To compare C strings, you have to write something as follows:

if (strcmp(a, b) == 0)

Furthermore, there is no way to use <, <=, >=, or > to compare C strings, so strcmp() returns -1, 0, or 1, depending on the lexicographic relationship of the strings. This results in very clumsy and hard-to-read code, which is also error-prone.

With C++ strings, operator==, operator!=, operator<, and so on are all overloaded to work on the actual string characters. Individual characters can still be accessed with operator[].

As the following code shows, when string operations require extending the string, the memory requirements are automatically handled by the string class, so memory overruns are a thing of the past:

string myString = "hello";
myString += ", there";
string myOtherString = myString;
if (myString == myOtherString) {
    myOtherString[0] = 'H';
}
cout << myString << endl;
cout << myOtherString << endl;

The output of this code is

hello, there
Hello, there

There are several things to note in this example. One point is that there are no memory leaks even though strings are allocated and resized on a few places. All of these string objects are created as stack variables. While the string class certainly has a bunch of allocating and resizing to do, the string destructors clean up this memory when string objects go out of scope.

Another point to note is that the operators work the way you want them to. For example, the = operator copies the strings, which is most likely what you want. If you are used to working with array-based strings, this will either be refreshingly liberating for you or somewhat confusing. Don’t worry—once you learn to trust the string class to do the right thing, life gets so much easier.

For compatibility, you can use the c_str() method on a string to get a const character pointer, representing a C-style string. However, the returned const pointer becomes invalid whenever the string has to perform any memory reallocation, or when the string object is destroyed. You should call the method just before using the result so that it accurately reflects the current contents of the string, and you must never return the result of c_str() called on a stack-based string object from a function.

There is also a data() method which, up until C++14, always returned a const char* just as c_str(). Starting with C++17, however, data() returns a char* when called on a non-const string.

Consult a Standard Library Reference, see Appendix B, for a complete list of all supported operations that you can perform on string objects.

std::string Literals

A string literal in source code is usually interpreted as a const char*. You can use the standard user-defined literal “s” to interpret a string literal as an std::string instead.

auto string1 = "Hello World";    // string1 is a const char*
auto string2 = "Hello World"s;   // string2 is an std::string

The standard user-defined literal “s” requires a using namespace std::string_literals; or using namespace std;.

High-Level Numeric Conversions

The std namespace includes a number of helper functions that make it easy to convert numerical values into strings or strings into numerical values. The following functions are available to convert numerical values into strings. All these functions take care of memory allocations. A new string object is created and returned from them.

• string to_string(int val);
• string to_string(unsigned val);
• string to_string(long val);
• string to_string(unsigned long val);
• string to_string(long long val);
• string to_string(unsigned long long val);
• string to_string(float val);
• string to_string(double val);
• string to_string(long double val);

These functions are pretty straightforward to use. For example, the following code converts a long double value into a string:

long double d = 3.14L;
string s = to_string(d);

Converting in the other direction is done by the following set of functions, also defined in the std namespace. In these prototypes, str is the string that you want to convert, idx is a pointer that receives the index of the first non-converted character, and base is the mathematical base that should be used during conversion. The idx pointer can be a null pointer, in which case it will be ignored. These functions ignore leading whitespace, throw invalid_argument if no conversion could be performed, and throw out_of_range if the converted value is outside the range of the return type.

• int stoi(const string& str, size_t *idx=0, int base=10);
• long stol(const string& str, size_t *idx=0, int base=10);
• unsigned long stoul(const string& str, size_t *idx=0, int base=10);
• long long stoll(const string& str, size_t *idx=0, int base=10);
• unsigned long long stoull(const string& str, size_t *idx=0, int base=10);
• float stof(const string& str, size_t *idx=0);
• double stod(const string& str, size_t *idx=0);
• long double stold(const string& str, size_t *idx=0);

Here is an example:

const string toParse = "   123USD";
size_t index = 0;
int value = stoi(toParse, &index);
cout << "Parsed value: " << value << endl;
cout << "First non-parsed character: '" << toParse[index] << "'" << endl;

The output is as follows:

Parsed value: 123
First non-parsed character: 'U'

Low-Level Numeric Conversions

The C++17 standard also provides a number of lower-level numerical conversion functions, all defined in the <charconv> header. These functions do not perform any memory allocations, but instead use buffers allocated by the caller. Additionally, they are tuned for high performance and are locale-independent (see Chapter 19 for details on localization). The end result is that these functions can be orders of magnitude faster than other higher-level numerical conversion functions. You should use these functions if you want high performant, locale-independent conversions, for example to serialize/deserialize numerical data to/from human readable formats such as JSON, XML, and so on.

For converting integers to characters, the following set of functions is available:

to_chars_result to_chars(char* first, char* last, IntegerT value, int base = 10);

Here, IntegerT can be any signed or unsigned integer type or char. The result is of type to_chars_result, a type defined as follows:

struct to_chars_result {
    char* ptr;
    errc ec;
};

The ptr member is either equal to the one-past-the-end pointer of the written characters if the conversion was successful, or it is equal to last if the conversion failed (in which case, ec == errc::value_too_large).

Here is an example of its use:

std::string out(10, ' ');
auto result = std::to_chars(out.data(), out.data() + out.size(), 12345);
if (result.ec == std::errc()) { /* Conversion successful. */ }

Using C++17 structured bindings introduced in Chapter 1, you can write it as follows:

std::string out(10, ' ');
auto [ptr, ec] = std::to_chars(out.data(), out.data() + out.size(), 12345);
if (ec == std::errc()) { /* Conversion successful. */ }

Similarly, the following set of conversion functions is available for floating point types:

to_chars_result to_chars(char* first, char* last, FloatT value);
to_chars_result to_chars(char* first, char* last, FloatT value,
                         chars_format format);
to_chars_result to_chars(char* first, char* last, FloatT value,
                         chars_format format, int precision);

Here, FloatT can be float, double, or long double. Formatting can be specified with a combination of chars_format flags:

enum class chars_format {
    scientific,                  // Style: (-)d.ddde±dd
    fixed,                       // Style: (-)ddd.ddd
    hex,                         // Style: (-)h.hhhp±d (Note: no 0x!)
    general = fixed | scientific // See next paragraph
};

The default format is chars_format::general, which causes to_chars() to convert the floating point value to a decimal notation in the style of (-)ddd.ddd, or to a decimal exponent notation in the style of (-)d.ddde±dd, whichever results in the shortest representation with at least one digit before the decimal point (if present). If a format is specified but no precision, the precision is automatically determined to result in the shortest possible representation for the given format, with a maximum precision of 6 digits.

For the opposite conversion—that is, converting character sequences into numerical values—the following set of functions is available:

from_chars_result from_chars(const char* first, const char* last,
                             IntegerT& value, int base = 10);
from_chars_result from_chars(const char* first, const char* last,
                             FloatT& value,
                             chars_format format = chars_format::general);

Here, from_chars_result is a type defined as follows:

struct from_chars_result {
    const char* ptr;
    errc ec;
};

The ptr member of the result type is a pointer to the first character that was not converted, or it equals last if all characters were successfully converted. If none of the characters could be converted, ptr equals first, and the value of the error code will be errc::invalid_argument. If the parsed value is too large to be representable by the given type, the value of the error code will be errc::result_out_of_range. Note that from_chars() does not skip any leading whitespace.

std::string_view Literals

You can use the standard user-defined literal “sv” to interpret a string literal as an std::string_view. For example:

auto sv = "My string_view"sv;

The standard user-defined literal “sv” requires a using namespace std::string_view_ literals; or using namespace std;.