8.3.2. string Functions: Documentation And Examples

The C++ string library begins with the string class and its member functions, but it also includes many non-member functions with at least one string argument. Member functions are defined in and belong to a class, making them class members. The string class constructors introduced previously are one kind of member function. The <string> header file also includes numerous functions using string objects without being class members.

C++ allows programmers to overload operators like + and =, and the string library overloads several, giving them new meanings when applied to string objects. Chapter 11 describes how programmers overload operators, but we need one detail now to understand the documentation for some frequently used string operators. "Overloading" means that a program reuses a name, so a program with overloaded functions has two or more functions with the same name. In the case of overloaded operators, the name consists of the keyword "operator" and the characters forming the operator. For example, operator⁠🙂, but with the operator replacing 🙂. The main difference between a "regular" function and an operator function is that operators support a novel calling syntax.

Although the text doesn't formally introduce classes and objects until the next chapter, one goal of the object-oriented paradigm is making it (relatively) easy for programmers to use them. We can usually understand the string functions and operators through their respective behaviors supported by abstract representations of their effect on the objects. There are too many functions and operators to remember (or cover) in detail. So, this section presents a few basic string functions and operators and directs you to the online documentation for details and more operations.

Basic string Operations

Documentation Prototypes	Example Function Calls
	string s = "Hello world";
(a)	(b)
size_t length(); size_t size();	for (int i = 0; i < s.length(); i++) . . . for (int j = 0; j < s.size(); j++) . . .
(c)	(d)
size_t capacity();	cout << s.length() << " " << s.capacity() <<endl;
(e)	(f)

char& operator[](size_t pos);

for (size_t i = 0; i < s.length(); i++)
	cout << s[i] << endl;

s[0] = 'X';

char& at(size_t pos);

for (size_t i = 0; i < s.length(); i++)
	cout << s.at(i) << endl;

s.at(0) = 'Z';

char& front();
char& back();

cout << s.front() << endl;
s.front() = "X';
cout << s.back() << endl;
s.back() = "Z';

string Construction Operators

string& operator=(const string& str);
string& operator=(const char* s);
string& operator=(char c);

string s1("hello");
string s2;
s2 = s1;
s2 = "hello";
s2 = 'X';

string operator+(const string& lhs, const string& rhs);
string operator+(const string& lhs, const char* rhs);
string operator+(const string& lhs, char rhs);

string s1("hello");
string s2(" world");
string s3;
s3 = s1 + s2;
s3 = s1 + " world";
s3 = s1 + s2 + '!';

string& operator+=(const string& str);
string& operator+=(const char* s);
string& operator+=(char c);

string s1("hello");
string s2(" world");
s2 += s2;
s1 += " world";
s1 += ' ';
s1 += "world";

Searching In strings

The string class also defines a symbolic constant named npos, which is the largest possible value for the data type size_t. String objects may contain at most npos characters, which means that when accessing individual characters within a string, legal index values, i, are in the range 0 ≤ i < npos. This arrangement allows any string function that returns an index into a string to return npos to indicate failure.

	string::npos
(a)	(b)

size_t find(const string& str, size_t pos = npos);
size_t find(const char* str, size_t pos = 0);
size_t find(const char c, size_t pos = 0);
 
 
 

string s = "Hello, World!";
size_t index = s.find("World");
if (index != string::npos)
	cout << "World found at " << index << endl;
else
	cout << "World not found." << endl;

size_t rfind(const string& str, size_t pos = npos);
size_t rfind(const char* str, size_t pos = 0);
size_t rfind(const char c, size_t pos = 0);
 
 
 

string s = "Hello, World!";
size_t index = s.rfind('l');
if (index != string::npos)
	cout << "'l' found at " << index << endl;
else
	cout << "'l' not found." << endl;
cout << s.rfind('l', 5) << endl;

Conversions: string To Number and Number To string

The console only "knows about" textual or character data. Whenever a program reads numeric data from or writes it to the console, it must convert between numbers and text. Library functions, like >> and <<, typically perform the conversions as part of the I/O process. But sometimes, a program must perform the conversion without performing any I/O (the palindrome-number problem, for example). The following figures illustrate some of the conversion functions.

Number To string Conversions: Documentation And Examples

int counter, i, j;
double x, y;

string to_string(int val);

string s1 = to_string(123);
string s2 = to_string(counter);
string s3 = to_string(i + j);

string to_string(double val);

string s4 = to_string(3.14159);
string s5 = to_string(x + y);
string s6 = to_string(pow(x + y));

string To Number Conversions: Documentation And Examples

string s1 = "123";
string s2 = "0XAF27"
string s3 = "3.14159";
size_t index;

int stoi(const string& str, size_t* index = 0, int base = 10);

cout << stoi(s1, &index) << endl;
cout << stoi(s2, &index, 16) << endl;

double stod(const string& str, size_t* index = 0);

cout << stod(s3, &index) << endl;

string s = "123hello"; int index = 0; ... int counter = stoi(s, &index);
(a)	(b)	(c)

Additional Resources

This section describes many of the most useful and frequently used string functions but does not represent a complete list. The following links present additional functions and greater detail. I recommend creating bookmarks for them in your web browser.