Chapter 21: Strings

Chapter 21 deals with the C++ strings library (a welcome relief).


MFC's CString

A common lament seen in various newsgroups deals with the Standard string class as opposed to the Microsoft Foundation Class called CString. Often programmers realize that a standard portable answer is better than a proprietary nonportable one, but in porting their application from a Win32 platform, they discover that they are relying on special functons offered by the CString class.

Things are not as bad as they seem. In this message, Joe Buck points out a few very important things:

The old libg++ library had a function called form(), which did much the same thing. But for a Standard solution, you should use the stringstream classes. These are the bridge between the iostream hierarchy and the string class, and they operate with regular streams seamlessly because they inherit from the iostream heirarchy. An quick example:

   #include <iostream>
   #include <string>
   #include <sstream>

   string f (string& incoming)     // incoming is something like "foo  N"
       istringstream   incoming_stream(incoming);
       string          the_word;
       int             the_number;

       incoming_stream >> the_word        // extract "foo"
                       >> the_number;     // extract N

       ostringstream   output_stream;
       output_stream << "The word was " << the_word
                     << " and 3*N was " << (3*the_number);

       return output_stream.str();

A serious problem with CString is a design bug in its memory allocation. Specifically, quoting from that same message:

   CString suffers from a common programming error that results in
   poor performance.  Consider the following code:
   CString n_copies_of (const CString& foo, unsigned n)
           CString tmp;
           for (unsigned i = 0; i < n; i++)
                   tmp += foo;
           return tmp;
   This function is O(n^2), not O(n).  The reason is that each +=
   causes a reallocation and copy of the existing string.  Microsoft
   applications are full of this kind of thing (quadratic performance
   on tasks that can be done in linear time) -- on the other hand,
   we should be thankful, as it's created such a big market for high-end
   ix86 hardware. :-)
   If you replace CString with string in the above function, the
   performance is O(n).

Joe Buck also pointed out some other things to keep in mind when comparing CString and the Standard string class:

Return to top of page or to the FAQ.

A case-insensitive string class

The well-known-and-if-it-isn't-well-known-it-ought-to-be Guru of the Week discussions held on Usenet covered this topic in January of 1998. Briefly, the challenge was, "write a 'ci_string' class which is identical to the standard 'string' class, but is case-insensitive in the same way as the (common but nonstandard) C function stricmp():"

   ci_string s( "AbCdE" );

   // case insensitive
   assert( s == "abcde" );
   assert( s == "ABCDE" );

   // still case-preserving, of course
   assert( strcmp( s.c_str(), "AbCdE" ) == 0 );
   assert( strcmp( s.c_str(), "abcde" ) != 0 ); 

The solution is surprisingly easy. The original answer pages on the GotW website have been removed into cold storage, in preparation for a published book of GotW notes. Before being put on the web, of course, it was posted on Usenet, and that posting containing the answer is available here.

See? Told you it was easy!

Return to top of page or to the FAQ.

Breaking a C++ string into tokens

The Standard C (and C++) function strtok() leaves a lot to be desired in terms of user-friendliness. It's unintuitive, it destroys the character string on which it operates, and it requires you to handle all the memory problems. But it does let the client code decide what to use to break the string into pieces; it allows you to choose the "whitespace," so to speak.

A C++ implementation lets us keep the good things and fix those annoyances. The implementation here is more intuitive (you only call it once, not in a loop with varying argument), it does not affect the original string at all, and all the memory allocation is handled for you.

It's called stringtok, and it's a template function. It's given in this file in a less-portable form than it could be, to keep this example simple (for example, see the comments on what kind of string it will accept). The author uses a more general (but less readable) form of it for parsing command strings and the like. If you compiled and ran this code using it:

   std::list<string>  ls;
   stringtok (ls, " this  \t is\t\n  a test  ");
   for (std::list<string>::const_iterator i = ls.begin();
        i != ls.end(); ++i)
       std::cerr << ':' << (*i) << ":\n";
You would see this as output:
with all the whitespace removed. The original s is still available for use, ls will clean up after itself, and ls.size() will return how many tokens there were.

As always, there is a price paid here, in that stringtok is not as fast as strtok. The other benefits usually outweight that, however. Another version of stringtok is given here, suggested by Chris King and tweaked by Petr Prikryl, and this one uses the transformation functions given below. If you are comfortable with reading the new function names, this version is recommended as an example.

Return to top of page or to the FAQ.

Simple transformations

Here are Standard, simple, and portable ways to perform common transformations on a string instance, such as "convert to all upper case." The word transformations is especially apt, because the standard template function transform<> is used.

      #include <string>
      #include <algorithm>
      #include <cctype>      // old <ctype.h>
      std::string  s ("Some Kind Of Initial Input Goes Here");
      // Change everything into upper case
      std::transform (s.begin(), s.end(), s.begin(), toupper);
      // Change everything into lower case
      std::transform (s.begin(), s.end(), s.begin(), tolower);
      // Change everything back into upper case, but store the
      // result in a different string
      std::string  capital_s;
      std::transform (s.begin(), s.end(), capital_s.begin(), tolower); 
Note that these calls all involve the global C locale through the use of the C functions toupper/tolower. This is absolutely guaranteed to work -- but only if you're using English text (bummer). A much better and more portable solution is to use a facet for a particular locale and call its conversion functions. (These are discussed more in Chapter 22.)

Another common operation is trimming off excess whitespace. Much like transformations, this task is trivial with the use of string's find family. These examples are broken into multiple statements for readability:

   std::string  str (" \t blah blah blah    \n ");

   // trim leading whitespace
   string::size_type  notwhite = str.find_first_not_of(" \t\n");

   // trim trailing whitespace
   notwhite = str.find_last_not_of(" \t\n"); 
Obviously, the calls to find could be inserted directly into the calls to erase, in case your compiler does not optimize named temporaries out of existance.

Return to top of page or to the FAQ.

Comments and suggestions are welcome, and may be sent to Phil Edwards or Gabriel Dos Reis.
$Id: howto.html,v 1.8 2000/03/20 22:16:21 pme Exp $