Finding Things in Strings

Problem

You want to search a string for something. Maybe it's a single character, another string, or one of (or not of) an unordered set of characters. And, for your own reasons, you have to find it in a particular way, such as the first or last occurrence, or the first or last occurrence relative to a particular index.

Solution

Use one of basic_string's "find" member functions. Almost all start with the word "find," and their name gives you a pretty good idea of what they do. Example 4-15 shows how some of the find member functions work.

Example 4-15. Searching strings

#include #include int main( ) { std::string s = "Charles Darwin"; std::cout << s.find("ar") << ' '; // Search from the // beginning std::cout << s.rfind("ar") << ' '; // Search from the end std::cout << s.find_first_of("swi") // Find the first of << ' '; // any of these chars std::cout << s.find_first_not_of("Charles") // Find the first << ' '; // that's not in this // set std::cout << s.find_last_of("abg") << ' '; // Find the first of // any of these chars // starting from the // end std::cout << s.find_last_not_of("aDinrw") // Find the first << ' '; // that's not in this // set, starting from // the end }

Each of the find member functions is discussed in more detail in the "Discussion" section.

Discussion

There are six different find member functions for finding things in strings, each of which provides four overloads. The overloads allow for either basic_string or charT* parameters (charT is the character type). Each has a basic_string::size_type parameter pos that lets you specify the index where the search should begin, and there is one overload with a size_type parameter n that allows you only to search based on the first n characters from the set.

It's hard to keep track of all of these member functions, so Table 4-2 gives a quick reference of each function and its parameters.

All of these member functions return the index of the occurrence of what you are looking for as a value of type basic_string::size_type. If the search fails, it returns basic_string::npos, which is a special value (usually -1) that indicates search failure. Even though it is usually -1, you should test for equality with npos to be as portable as possible; this also makes your intent clear, since by comparing to npos you are explicitly checking for search failure and not some magic number.

With this variety of searching algorithms, you should be able to find what you're looking for, and if not, to use them in your own algorithms. If basic_string doesn't provide what you need, however, look in before you roll your own. The standard algorithms operate on sequences by using iterators and, nearly as often, function objects. Conveniently, basic_strings provide iterators for easy traversal, so it is trivial to plug string iterators into standard algorithms. Say you want to find the first occurrence of the same character twice in a row. You can use the adjacent_find function template to find two equal, adjacent elements in a string ("adjacent" means that their positions differ by one iterator, i.e., that *iter == *(iter + 1)).

std::string s = "There was a group named Kiss in the 70s"; std::string::iterator p = std::adjacent_find(s.begin( ), s.end( ));

The result is an iterator that points to the first of the adjacent elements.

If you have to write your own algorithm for operating on strings, don't use a basic_string like you would a C-style string by using operator[] to get at each item. Take advantage of the existing member functions. Each of the find functions takes a size_type parameter that indicates the index where the search should proceed from. Using the find functions repeatedly, you can advance through the string as you see fit. Consider Example 4-16, which counts the number of unique characters in a string.

Example 4-16. Counting unique characters

#include #include template int countUnique(const std::basic_string& s) { using std::basic_string; basic_string chars; for (typename basic_string::const_iterator p = s.begin( ); p != s.end( ); ++p) { if (chars.find(*p) == basic_string::npos) chars += *p; } return(chars.length( )); } int main( ) { std::string s = "Abracadabra"; std::cout << countUnique(s) << ' '; }

The find functions come in handy quite often. Keep them at the top of the list when you have to find things in strings.