8.2 The Standard `string` Class

I try to catch every sentence, every word you and I say, and quickly lock all these sentences and words away in my literary storehouse because they might come in handy.

ANTON CHEKHOV, The Seagull

In Section 8.1, we introduced C strings. These C strings were simply arrays of characters terminated with the null character '\0'. In order to manipulate these C strings, you needed to worry about all the details of handling arrays. For example, when you want to add characters to a C string and there is not enough room in the array, you must create another array to hold this longer string of characters. In short, C strings require the programmer to keep track of all the low-level details of how the C strings are stored in memory. This is a lot of extra work and a source of programmer errors. The ANSI/ISO standard for C++ specified that C++ must also have a class string that allows the programmer to treat strings as a basic data type without needing to worry about implementation details. In this section we introduce you to this string type.

Introduction to the Standard Class `string`

The class string is defined in the library whose name is also <string>, and the definitions are placed in the std namespace. So, in order to use the class string, your code must contain the following (or something more or less equivalent):

#include <string>
using namespace std;

The class string allows you to treat string values and string expressions very much like values of a simple type. You can use the = operator to assign a value to a string variable, and you can use the + sign to concatenate two strings. For example, suppose s1, s2, and s3 are objects of type string and both s1 and s2 have string values. Then s3 can be set equal to the concatenation of the string value in s1 followed by the string value in s2 as follows:

s3 = s1 + s2;

There is no danger of s3 being too small for its new string value. If the sum of the lengths of s1 and s2 exceeds the capacity of s3, then more space is automatically allocated for s3.

As we noted earlier in this chapter, quoted strings are really C strings and so they are not literally of type string. However, C++ provides automatic type casting of quoted strings to values of type string. So, you can use quoted strings as if they were literal values of type string, and we (and most others) will often refer to quoted strings as if they were values of type string. For example,

s3 = "Hello Mom!";

sets the value of the string variable s3 to a string object with the same characters as in the C string "Hello Mom!".

The class string has a default constructor that initializes a string object to the empty string. The class string also has a second constructor that takes one argument that is a standard C string and so can be a quoted string. This second constructor initializes the string object to a value that represents the same string as its C-string argument. For example,

string phrase;
string noun("ants");

The first line declares the string variable phrase and initializes it to the empty string. The second line declares noun to be of type string and initializes it to a string value equivalent to the C string "ants". Most programmers when talking loosely would say that “noun is initialized to "ants",” but there really is a type conversion here. The quoted string "ants" is a C string, not a value of type string. The variable noun receives a string value that has the same characters as "ants" in the same order as "ants", but the string value is not terminated with the null character '\0'. In fact, in theory at least, you do not know or care whether the string value of noun is even stored in an array, as opposed to some other data structure.

There is an alternate notation for declaring a string variable and invoking a constructor. The following two lines are exactly equivalent:

string noun("ants");
string noun = "ants";

These basic details about the class string are illustrated in Display 8.4. Note that, as illustrated there, you can output string values using the operator <<.

An illustration shows a program demonstrating the use of the “Class” string. — Display 8.4 Program Using the Class `string`

Figure 8.4 Full Alternative Text

Consider the following line from Display 8.4:

phrase = "I love " + adjective + " " + noun + "!";

C++ must do a lot of work to allow you to concatenate strings in this simple and natural fashion. The string constant "I love" is not an object of type string. A string constant like "I love" is stored as a C string (in other words, as a null-terminated array of characters). When C++ sees "I love" as an argument to +, it finds the definition (or overloading) of + that applies to a value such as "I love". There are overloadings of the + operator that have a C string on the left and a string on the right, as well as the reverse of this positioning. There is even a version that has a C string on both sides of the + and produces a string object as the value returned. Of course, there is also the overloading you expect, with the type string for both operands.

C++ did not really need to provide all those overloading cases for +. If these overloadings were not provided, C++ would look for a constructor that could perform a type conversion to convert the C string "I love" to a value for which + did apply. In this case, the constructor with the one C-string parameter would perform just such a conversion. However, the extra overloadings are presumably more efficient.

The class string is often thought of as a modern replacement for C strings. However, in C++ you cannot easily avoid also using C strings when you program with the class string.

The Class `string`

The class string can be used to represent values that are strings of characters. The class string provides more versatile string representation than the C strings discussed in Section 8.1.

The class string is defined in the library that is also named <string>, and its definition is placed in the std namespace. So, programs that use the class string should contain the following (or something more or less equivalent):

#include <string>
using namespace	 std;

The class string has a default constructor that initializes the string object to the empty string and a constructor that takes a C string as an argument and initializes the string object to a value that represents the string given as the argument. For example:

string s1, s2(“Hello”);

I/O with the Class `string`

You can use the insertion operator << and cout to output string objects just as you do for data of other types. This is illustrated in Display 8.4. Input with the class string is a bit more subtle.

The extraction operator >> and cin work the same for string objects as for other data, but remember that the extraction operator ignores initial whitespace and stops reading when it encounters more whitespace. This is as true for strings as it is for other data. For example, consider the following code:

string s1, s2;
cin >> s1;
cin >> s2;

If the user types in

May the hair on your toes grow long and curly!

then s1 will receive the value "May" with any leading (or trailing) whitespace deleted. The variable s2 receives the string "the". Using the extraction operator >> and cin, you can only read in words; you cannot read in a line or other string that contains a blank. Sometimes this is exactly what you want, but sometimes it is not at all what you want.

If you want your program to read an entire line of input into a variable of type string, you can use the function getline. The syntax for using getline with string objects is a bit different from what we described for C strings in Section 8.1. You do not use cin.getline; instead, you make cin the first argument to getline.2 (Thus, this version of getline is not a member function.)

string line;
cout << "Enter a line of input:\n";
getline(cin, line);
cout << line << "END OF OUTPUT\n";

When embedded in a complete program, this code produces a dialogue like the following:

Enter some input:
Do bedo to you!
Do bedo to you!END OF OUTPUT

If there were leading or trailing blanks on the line, then they too would be part of the string value read by getline. This version of getline is in the library <string>. You can use a stream object connected to a text file in place of cin to do input from a file using getline.

You cannot use cin and >> to read in a blank character. If you want to read one character at a time, you can use cin.get, which we discussed in Chapter 6. The function cin.get reads values of type char, not of type string, but it can be helpful when handling string input. Display 8.5 contains a program that illustrates both getline and cin.get used for string input. The significance of the function newLine is explained in the Pitfall subsection entitled Mixing cin >> variable and getline

Display 8.5 Program Using the Class `string`

 1	 //Demonstrates getline and cin.get.
 2	  #include <iostream>
 3	  #include <string>
 4	  void newLine( );
 5	  int main( )
 6	  {
 7		  using namespace std;
 8	   
 9		  string firstName, lastName, recordName;
10		  string motto = "Your records are our records.";
11		  cout << "Enter your first and last name:\n";
12		  cin >> firstName>>lastName;
13		  newLine( );
14		  recordName = lastName + ", " + firstName;
15		  cout << "Your name in our records is: ";
16		  cout << recordName<<endl;
17		  cout << "Our motto is\n"
18			   << motto <<endl;
19		  cout << "Please suggest a better (one-line) motto:\n";
20		  getline(cin, motto);
21		  cout << "Our new motto will be:\n";
22		  cout << motto <<endl;
23		  return 0;
24	  }
25	   
26	  //Uses iostream:
27	  void newLine( )
28	  {
29		  using namespace  std;
30	   
31		char nextChar;
32		  do
33		  {
34			  cin.get(nextChar);
35		  } while (nextChar != '\n');
36	  }

Sample Dialogue

Enter your first and last name:
B'Elanna Torres
Your name in our records is: Torres, B'Elanna
Our motto is
Your records are our records.
Please suggest a better (one-line) motto:
Our records go where no records dared to go before.
Our new motto will be:
Our records go where no records dared to go before.

I/O with `string` Objects

You can use the insertion operator << with cout to output string objects. You can input a string with the extraction operator >> and cin. When using >> for input, the code reads in a string delimited with whitespace. You can use the function getline to input an entire line of text into a string object.

Examples

string greeting(“Hello”), response, nextWord;
cout << greeting << endl;
getline(cin, response);
cin >> nextWord;

Self-Test Exercises

Consider the following code (and assume that it is embedded in a complete and correct program and then run):
```
string s1, s2;
cout << "Enter a line of input:\n";
cin >> s1 >> s2;
cout << s1 << "*" << s2 << "<END OF OUTPUT";
```
If the dialogue begins as follows, what will be the next line of output?
```
Enter a line of input:
A string is a joy forever!
```
Consider the following code (and assume that it is embedded in a complete and correct program and then run):
```
string s;
cout << "Enter a line of input:\n";
getline(cin, s);
cout << s << "<END OF OUTPUT";
```
If the dialogue begins as follows, what will be the next line of output?
```
Enter a line of input:
A string is a joy forever!
```

Programming Tip More Versions of `getline`

So far, we have described the following way of using getline:

string line;
cout << "Enter a line of input:\n";
getline(cin, line);

This version stops reading when it encounters the end-of-line marker '\n'. There is a version that allows you to specify a different character to use as a stopping signal. For example, the following will stop when the first question mark is encountered:

string line;
cout << "Enter some input:\n";
getline(cin, line, '?');

It makes sense to use getline as if it were a void function, but it actually returns a reference to its first argument, which is cin in the code above. Thus, the following will read a line of text into s1 and a string of nonwhitespace characters into s2:

string s1, s2;
getline(cin, s1) >> s2;

The invocation getline (cin,s1) returns a reference to cin, so that after the invocation of getline, the next thing to happen is equivalent to

cin >> s2;

This kind of use of getline seems to have been designed for use in a C++ quiz show rather than to meet any actual programming need, but it can come in handy sometimes.

Pitfall Mixing `cin >> variable;` and `getline`

Take care in mixing input using cin >> variable; with input using getline. For example, consider the following code:

int n;
string line;
cin >> n;
getline(cin, line);

`getline` for Objects of the Class `string`

The getline function for string objects has two versions:

istream& getline(istream& ins, string& strVar,
				  char delimiter);

and

istream& getline(istream& ins, string& strVar);

The first version of this function reads characters from the istream object given as the first argument (always cin in this chapter), inserting the characters into the string variable strVar until an instance of the delimiter character is encountered. The delimiter character is removed from the input and discarded. The second version uses '\n' for the default value of delimiter; otherwise, it works the same.

These getline functions return their first argument (always cin in this chapter), but they are usually used as if they were void functions.

When this code reads the following input, you might expect the value of n to be set to 42 and the value of line to be set to a string value representing "Hello hitchhiker.":

42
Hello hitchhiker.

However, while n is indeed set to the value of 42, line is set equal to the empty string. What happened?

Using cin >> n skips leading whitespace on the input, but leaves the rest of the line, in this case just '\n', for the next input. A statement like

cin >> n;

always leaves something on the line for a following getline to read (even if it is just the '\n'). In this case, the getline sees the '\n' and stops reading, so getline reads an empty string. If you find your program appearing to mysteriously ignore input data, see if you have mixed these two kinds of input. You may need to use either the newLine function from Display 8.5 or the function ignore from the library iostream. For example,

cin.ignore(1000, '\n');

With these arguments, a call to the ignore member function will read and discard the entire rest of the line up to and including the '\n' (or until it discards 1000 characters if it does not find the end of the line after 1000 characters).

There can be other baffling problems with programs that use cin with both >> and getline. Moreover, these problems can come and go as you move from one C++ compiler to another. When all else fails, or if you want to be certain of portability, you can resort to character-by-character input using cin.get.

These problems can occur with any of the versions of getline that we discuss in this chapter.

String Processing with the Class `string`

The class string allows you to perform the same operations that you can perform with the C strings we discussed in Section 8.1 and more. You can access the characters in a string object in the same way that you access array elements, so string objects have all the advantages of arrays of characters plus a number of advantages that arrays do not have, such as automatically increasing their capacity. If lastName is the name of a string object, then lastName[i] gives access to the ith character in the string represented by lastName. This use of array square brackets is illustrated in Display 8.6.

Display 8.6 A `string` Object Can Behave Like an Array

 1	 //Demonstrates using a string object as if it were an array.
 2	  #include <iostream>
 3	  #include <string>
 4	  using namespace  std;
 5	  int main( )
 6	  {
 7		  string firstName, lastName;
 8		  cout << "Enter your first and last name:\n";
 9		  cin >> firstName>>lastName;
10		  cout << "Your last name is spelled:\n";
11		  int i;
12		  for (i = 0; i <lastName.length( ); i++)
13		  {
14			  cout << lastName[i] << " ";
15			  lastName[i] = '-';
16		  }
17		  cout << endl;
18		  for (i = 0; i <lastName.length( ); i++)
19			  cout << lastName[i] << " ";  //Places a "-" under each letter.
20		  cout << endl;
21		  cout << "Good day " << firstName << endl;
22		  return  0;
23	  }

Sample Dialogue

Enter your first and last name:
John Crichton 
Your last name is spelled:
C r i c h t o n
– – – – – – – –
Good day John

Display 8.6 also illustrates the member function length. Every string object has a member function named length that takes no arguments and returns the length of the string represented by the string object. Thus, not only can a string object be used like an array but the length member function makes it behave like a partially filled array that automatically keeps track of how many positions are occupied.

When used with an object of the class string, the array square brackets do not check for illegal indexes. If you use an illegal index (that is, an index that is greater than or equal to the length of the string in the object), then the results are unpredictable but are bound to be bad. You may just get strange behavior without any error message that tells you that the problem is an illegal index value.

There is a member function named at that does check for illegal index values. This member function behaves basically the same as the square brackets, except for two points: You use function notation with at, so instead of a[i], you use a.at(i); and the at member function checks to see if i evaluates to an illegal index. If the value of i in a.at(i) is an illegal index, then you should get a run-time error message telling you what is wrong. In the following two example code fragments, the attempted access is out of range, yet the first of these probably will not produce an error message, although it will be accessing a nonexistent indexed variable:

string str("Mary");
cout << str[6] << endl;

The second example, however, will cause the program to terminate abnormally, so you at least know that something is wrong:

string str("Mary");
cout << str.at(6) << endl;

But be warned that some systems give very poor error messages when str.at(i) has an illegal index i.

You can change a single character in the string by assigning a char value to the indexed variable, such as str[i]. This may also be done with the member function at. For example, to change the third character in the string object str to 'X', you can use either of the following code fragments:

str.at(2) = 'X';

str[2] = 'X';

As in an ordinary array of characters, character positions for objects of type string are indexed starting with 0, so the third character in a string is in index position 2.

Display 8.7 gives a partial list of the member functions of the class string. In many ways, objects of the class string are better behaved than the C strings we introduced in Section 8.1. In particular, the == operator on objects of the string class returns a result that corresponds to our intuitive notion of strings being equal—namely, it returns true if the two strings contain the same characters in the same order, and returns false otherwise. Similarly, the comparison operators <, >, < =, > = compare string objects using lexicographic ordering. (Lexicographic ordering is alphabetic ordering using the order of symbols given in the ASCII character set in Appendix 3. If the strings consist of all letters and are both either all uppercase or all lowercase letters, then for this case lexicographic ordering is the same as everyday alphabetical ordering.)

Display 8.7 Member Functions of the Standard Class `string`

Example	Remarks
Constructors
`string str;`	Default constructor creates empty string object `str`.
`string str("sample");`	Creates a string object with data “sample”.
`string str(aString);`	Creates a string object str that is a copy of aString; aString is an object of the class string.
Accessors
`str[i]`	Returns read/write reference to character in `str` at index `i`. Does not check for illegal index.
`str.at(i)`	Returns read/write reference to character in str at index `i`. Same as `str[i]`, but this version checks for illegal index.
`str.substr(position, length)`	Returns the substring of the calling object starting at `position` and having `length` characters.
`str.length( )`	Returns the length of `str`.
Assignment/Modifiers
`str1 = str2;`	Initializes `str1` to `str2's` data.
`str1 += str2;`	Character data of `str2` is concatenated to the end of `str1`.
`str.empty( )`	Returns true if `str` is an empty string; false otherwise.
`str1 + str2`	Returns a string that has `str2's` data concatenated to the end of `str1's` data.
`str.insert(pos, str2);`	Inserts `str2` into `str` beginning at position `pos`.
`str.erase(pos, length);`	Removes substring of size `length`, starting at position `pos`.
Comparison
`str1 == str2 str1 != str2`	Compare for equality or inequality; returns a Boolean value.
`str1 < str2 str1 > str2`	Four comparisons. All are lexicographical comparisons.
`str1 <= str2 str1 >= str2`
Finds
`str.find(str1)`	Returns index of the first occurrence of `str1` in `str`. If `str1` is not found, then the special value `string::npos` is returned.
`str.find(str1, pos)`	Returns index of the first occurrence of string `str1` in `str;` the search starts at position `pos`.
`str.find_first_of(str1, pos)`	Returns the index of the first instance in `str` of any character in `str1`, starting the search at position `pos`.
`str.find_first_not_of (str1, pos)`	Returns the index of the first instance in `str` of any character not in `str1`, starting the search at position `pos`.

Programming Example Palindrome Testing

A palindrome is a string that reads the same front to back as it does back to front. The program in Display 8.8 tests an input string to see if it is a palindrome. Our palindrome test will disregard all spaces and punctuations and will consider upper- and lowercase versions of a letter to be the same when deciding if something is a palindrome. Some palindrome examples are as follows:

Able was I ere I saw Elba.
I Love Me, Vol. I.
Madam, I’m Adam.
A man, a plan, a canal, Panama.
Rats live on no evil star.
radar
deed
mom
racecar

Display 8.8 Palindrome Testing Program

 1	 //Test for palindrome property.
 2	  #include <iostream>
 3	  #include <string>
 4	  #include <cctype>
 5	  using namespace std;
 6	  void swap	(char& v1, char& v2);
 7	  //Interchanges the values of v1 and v2.
 8	  string reverse(const string& s);
 9	  //Returns a copy of s but with characters in reverse order.
10	  string removePunct(const string& s, const string& punct);
11	  //Returns a copy of s with any occurrences of characters
12	  //in the string punct removed.
13	  string makeLower(const string& s);
14	  //Returns a copy of s that has all uppercase
15	  //characters changed to lowercase, other characters unchanged.
16	  bool isPal(const string& s);
17	  //Returns true if s is a palindrome, false otherwise.
18	  int  main( )
19	  {
20		  string str;
21		cout << "Enter a candidate for palindrome test\n"
22			   << "followed by pressing Return.\n";
23		  getline(cin, str);
24		  if (isPal(str))
25			  cout << "\"" <<str + "\" is a palindrome.";
26		  else
27			  cout << "\"" <<str + "\" is not a palindrome.";
28		  cout << endl;
29		  return  0;
30	  }
31	   
32	  void	swap(char& v1,	char& v2)
33	  {
34		  char temp = v1;
35		  v1 = v2;
36		  v2 = temp;
37	  }
38	   
39	  string reverse(const	string& s)
40	  {
41		  int start = 0;
42		  int end = s.length( );
43		  string temp(s);
44	   
45		  while (start < end)
46		  {
47			  end−−;
48			  swap(temp[start], temp[end]);
49			  start++;
50		  }
51		  return temp;
52	  }
53	  //Uses <cctype> and <string>
54	  string makeLower(const string& s)
55	  {
56		  string temp(s);
57		  for (int i = 0; i < s.length( ); i++)
58			  temp[i] = tolower(s[i]);
59		  return temp;
60	  }
61	  string removePunct(const	string& s,	const  string& punct)
62	  {
63		  string noPunct; //initialized to empty string
64		  int sLength = s.length( );
65		  int punctLength = punct.length( ); 
66		 for (int i = 0; i < sLength; i++)
67		   {
68			  string aChar = s.substr(i,1);	 //A one-character string
69			  int location = punct.find(aChar, 0);
70			  //Find location of successive characters
71			  //of src in punct.
72		   if (location < 0 || location >= punctLength)
73			  noPunct = noPunct + aChar; //aChar not in punct, so keep it
74		   }
75		   return  noPunct;
76	  }
77	   
78	  //uses functions makeLower, removePunct
79	  bool isPal(const string& s)
80	  {
81		   string punct(",;:.?!'\" ");	//includes a blank
82		   string str(s);
83		   str = makeLower(str);
84		   string lowerStr = removePunct(str, punct);
85		   return (lowerStr == reverse(lowerStr));
86	  }

Sample Dialogue

Enter a candidate for palindrome test
followed by pressing Return.
Madam, I'm Adam.
"Madam, I'm Adam." is a palindrome.

Sample Dialogue

Enter a candidate for palindrome test
followed by pressing Return.
Radar
"Radar" is a palindrome.

Sample Dialogue

Enter a candidate for palindrome test
followed by pressing Return.
Am I a palindrome?
"Am I a palindrome?" is not a palindrome.

The removePunct function is of interest in that it uses the string member functions substr and find. The member function substr extracts a substring of the calling object, given the position and length of the desired substring.

The first three lines of removePunct declare variables for use in the function. The for loop runs through the characters of the parameters one at a time and tries to find them in the punct string. To do this, a string that is the substring of s, of length 1 at each character position, is extracted. The position of this substring in the punct string is determined using the find member function. If this one-character string is not in the punct string, then the one-character string is concatenated to the noPunct string that is to be returned.

Self-Test Exercises

Consider the following code:

string s1, s2("Hello");
cout << "Enter a line of input:\n";
cin >> s1;
if (s1 == s2)
	cout << "Equal\n";
else	 cout << "Not equal\n";

If the dialogue begins as follows, what will be the next line of output?

Enter a line of input:
Hello friend!

What is the output produced by the following code?

string s1, s2("Hello");
s1 = s2;
s2[0] = 'J';
cout << s1 << " " << s2;

Converting Between `string` Objects and C Strings

You have already seen that C++ will perform an automatic type conversion to allow you to store a C string in a variable of type string. For example, the following will work fine:

char aCString[] = "This is my C string.";
string stringVariable;
stringVariable = aCString;

However, the following will produce a compiler error message:

aCString = stringVariable; //ILLEGAL

The following is also illegal:

strcpy(aCString, stringVariable); //ILLEGAL

strcpy cannot take a string object as its second argument, and there is no automatic conversion of string objects to C strings, which is the problem we cannot seem to get away from.

To obtain the C string corresponding to a string object, you must perform an explicit conversion. This can be done with the string member function c_str( ). The correct version of the copying we have been trying to do is the following:

strcpy(aCString, stringVariable.c_str( ));  //Legal;

Note that you need to use the strcpy function to do the copying. The member function c_str( ) returns the C string corresponding to the string calling object. As we noted earlier in this chapter, the assignment operator does not work with C strings. So, just in case you thought the following might work, we should point out that it too is illegal.

aCString = stringVariable.c_str( );	//ILLEGAL

Converting Between Strings and Numbers

Prior to C++11 it was a bit complicated to convert between strings and numbers, but in C++11 it is simply a matter of calling a function. Use stof, stod, stoi, or stol to convert a string to a float, double, int, or long, respectively. Use to_string to convert a numeric type to a string. These functions are illustrated in the following example:

int i;
double d;
string s;
i = stoi("35"); // Converts the string "35" to an integer 35
d = stod("2.5"); // Converts the string "2.5" to the double 2.5
s = to_string(d*2); // Converts the double 5.0 to a string "5.0000"
cout << i << " " << d << " " << s << endl;

The output is 35 2.5 5.0000