364 Part V: Optional Features
The string Container
The most common form of array is the zero-terminated character string used to display text, which clearly shows both the advantages and disadvantages of the array. Consider how easy the following appears:
cout << “This is a string”;
But things go sour quickly when you try to perform an operation even as simple as concatenating two strings:
char* concatCharString(char* s1, char* s2)
{
int length = strlen(s1) + strlen(s2) + 1; char* s = new char[length];
strcpy(s, s1); strcat(s, s2); return s;
}
The STL provides a string container to handle display strings. The string class provides a number of operations (including overloaded operators) to simplify the manipulation of character strings. The same concat() operation is performed as follows using string objects:
string concat(string s1, string s2)
{
return s1 + s2;
}
I tried to avoid using string class in other chapters in this book because I don’t explain it until here. However, most programmers use the string class more often than they use null terminated character arrays.
The following STLString program demonstrates just a few of the capabilities of the string class:
//STLString - demonstrates just a few of the features
//of the string class which is part of the
//Standard Template Library
#include <string> #include <cstdlib> #include <iostream> using namespace std;
// concat - return the concatenation of two strings string concat(string s1, string s2)
{
return s1 + s2;
}
Chapter 28: Standardizing on the Standard Template Library 365
// removeSpaces - remove any spaces within a string string removeSpaces(string s)
{
//find the offset of the first space;
//keep searching the string until no more spaces found size_t offset;
while((offset = s.find(“ “)) != -1)
{
//remove the space just discovered
s.erase(offset, 1);
}
return s;
}
// insertPhrase - insert a phrase in the position of // <ip> for insertion point
string insertPhrase(string source)
{
size_t offset = source.find(“<ip>”); if (offset != -1)
{
source.erase(offset, 4); source.insert(offset, “Randall”);
}
return source;
}
int main(int argc, char* pArgs[])
{
//create a string that is the sum of two smaller strings cout << “string1 + string2 = “
<<concat(“string1 “, “string2”)
<<endl;
//create a test string and then remove all spaces from
//it using simple string methods
string s2(“The phrase”);
cout << “<” << s2 << “> minus spaces = <”
<<removeSpaces(s2) << “>” << endl;
//insert a phrase within the middle of an existing
//sentence (at the location of “<ip>”)
string s3 = “Stephen <ip> Davis”;
cout << s3 + “ -> “ + insertPhrase(s3) << endl;
system(“PAUSE”); return 0;
}
The operator+() operation performs the concatenation function that earlier sessions implemented using the concatCharacterString() method.
366 Part V: Optional Features
The removeSpaces() method removes any spaces found within the string provided. It does this by using the string.find() operation to return the offset of the first “ ” that it finds. Once found, removeSpaces() uses the erase() method to remove the space. The find() method returns an offset of –1 when no more spaces are left.
The type size_t is defined within the STL include files as an integer that can handle the largest array index possible on your machine. This is typically a long of some type; however, the size_t is used to further source code porta bility between computers. Visual Studio C++.NET will generate a warning if you use int instead.
The insertPhrase() method uses the find() method to find the insertion point. It then calls erase to remove the “<ip>” flag and the string.insert() to insert a new string within the middle of an existing string.
The resulting output is as follows:
string1 + string2 = string1 string2
<this is a test string> minus spaces = <thisisateststring>
Stephen <ip> Davis -> Stephen Randall Davis
Press any key to continue . . .
The list Containers
The Standard Template Library provides a large number of containers — many more than I can describe in a single session. However, I provide here a description of two of the more useful families of containers.
The STL list container retains objects by linking them together like Lego blocks. Objects can be snapped apart and snapped back together in any order. This makes the list ideal for inserting objects, sorting, merging, and otherwise rearranging objects. The following example STLList program uses the list container to sort a set of names:
//STLList - use the list container of the
//Standard Template Library to input
//and sort a string of names #include <list>
#include <string> #include <cstdio> #include <cstdlib> #include <iostream>
//declare a list of string objects
using namespace std; list<string> names;
Chapter 28: Standardizing on the Standard Template Library 367
int main(int argc, char* pArgs[])
{
// input a string of names
cout << “Input a name (input a null to terminate list)” << endl;
while(true)
{
string name; cin >> name;
if ((name.compare(“x”) == 0) || (name.compare(“X”) == 0))
{
break;
}
names.push_back(name);
}
//sort the list
//(this works since String implements a comparison
operator)
names.sort();
//display the sorted list
//keep displaying names until the collection is empty cout << “\nSorted output:” << endl; while(!names.empty())
{
//get the first name in the list
string name = names.front(); cout << name << endl;
// remove that name from the list names.pop_front();
}
system(“PAUSE”); return 0;
}
This example defines the variable names to be a list of string objects. The program starts by reading names from the keyboard. Each name is added to the end of the list names using the push_back() method. The program exits the loop when the user enters the name “x”. The list of names is sorted by invoking the single list method sort().
The program displays the sorted list of names by removing objects from the front of the list until the list is empty.
The following is an example output from the program: