Title: Mixing Strings in C++

Every (sane) programming language has some mechanism to handle text strings. Text strings are basically a sequence of characters. But this sequence can be implemented in different ways, which are not always interchangeable in a simple and efficient way.

This article is not going into the realm of how characters are represented and conversions between character representations, instead the interaction between different string implementations are investigated.

There is only one string type in C. This makes life easy as there is no confusion in the choice of string type to use. C uses a linear sequence of characters terminated by a null character. This sequence is either kept in an array or some other memory pointed to by a pointer. An array of characters is easily converted to a pointer to characters and this makes it easy to pass around pointers to characters in function parameters and data structures. The pointers are so often used to represent strings that they often are referred to as strings and not pointers to strings.

Working with these C strings is not always easy, as the memory for the character sequence must be managed by the programmer. To append a string to another you must reserve a piece of memory to store the new string, then copy the original string and append the second string to this. Then you can use a pointer to this new memory as the result string. Just don't forget to free the memory of the original string to avoid memory leakage, but not if anyone else is still using a pointer to it! This handling gets even worse when you need to merge several strings, for example when adding a file name to a directory name:

char * dirname = ...;
char * filename = ...;
char * tmpdirname;

// Length of new string includes directory
// separator and null character
int newlen = strlen(dirname) +
             strlen(filename) + 2;
tmpdirname = (char *) malloc(newlen);
if (tmpdirname == NULL) {
  // Handle memory error.
}
strcpy(tmpdirname, dirname);
strcat(tmpdirname, "/");
strcat(tmpdirname, filename);
free(dirname);
dirname = tmpdirname;

Of course, most developers wrap such functionality in utility libraries. However, the amount of variations of semantics makes such libraries difficult to use. In this example, we append a filename to a directory name that involves a third string temporarily. Yes, a simple function to append a string to another could be used within this function but then there would be two calls to that function and thus two memory allocations. So two functions are needed, one for simple string append and one for file name append. For every special semantic variation needed, the number of functions increases.

What if the directory name referred to by dirname cannot be freed? It might be a pointer to a string literal or a character sequence stored in an array on the stack and cannot be freed. Or the string is still used somewhere else in the program. We need to have two variations each of the functions in the library, one that frees the original string and one that leaves it intact. Sometimes the variants that free memory are left out and the user of the functions has to remember to free the memory.

C++ provides the capability to create a string class that manages the underlying memory and makes strings easier to use. Standard C++ [ ISO-IEC] introduced a string class in the library to encapsulate the semantics of strings. Appending a file name to a directory name using the C++ string type is much simpler:

std::string dirname = ...;
std::string filename = ...;

dirname = dirname + "/" + filename;

Note that the error handling is done with exceptions here. This may look like cheating. But exceptions are intended to let code avoid error handling in the cases where nothing can be done other than pass the error on to a higher level.

So using a string class makes life easier for the programmer. Sadly, this is not the only way strings are used in C++. C++ has inherited much from C, including its string concept. Many libraries use C strings (pointers) for function parameters and data structures so both C and C++ programs can use them. One such library many C++ programmers use is the C library. C strings are also used in some parts of the C++ library where exceptions cannot be thrown.

C++ strings are very convenient to use. C strings are relatively easy to use if ownership of the memory is managed properly. However, mixing them can cause a few headaches.

// A function that promises not to modify
// the string.
extern void f(const char *);
std::string myString = ...;

f(myString.c_str());

// A function that promises not to modify
// the string.
void g(std::string const &);
char* myString = ...;

g(myString);

To make things worse, there are several custom string class implementations around. Some predate the C++ standard and some add various features needed in their projects. These non-standard string classes usually work in a similar way to std::string but have some minor additions or omissions that make them difficult to replace with std::string.

My most recent project uses two custom string types. The first is a home-made string dating from the days before the C++ standard that also adds a hash value for the string (called xstring). This hash value was used in various tables to find the string quickly.

The other custom string type is a convenience class, a wrapper for std::string (called U_String). It is derived from std::string and thus behaves exactly like it, but can be forward declared without any #include. This is very useful for header files that only declare string parameters passed by const-reference. (Where the type is only used by name.) The header file <string> includes <iostream> in some libraries, which can be very heavy for the compiler, especially when precompiled headers cannot be used. Compile times were reduced significantly when the U_String class was introduced because the project consisted of a large number of small translation units.

Older parts of the project use the xstring class while newer parts use U_String. Converting between them is trivial to code but requires creation of a temporary object. Usage of the xstring class is slowly being replaced by U_String where the hash value isn't used. The intent is to remove the xstring class completely. The need for the hash value will be replaced by a flyweight string (see below).

The C++ string is a powerful tool. It does a very good job to represent a string. However, there are some problems with it for power-users.

In most library implementations, each string object keeps a copy of the character sequence in a piece of memory it owns. This may be expensive if the same string is copied many times.

Some implementations have solved this by sharing exact copies between copied string objects by keeping a reference count for the memory that contains the character sequence. The memory is shared until a string object is modified. It then gets a bit of memory for itself. This is called COW-strings. (Copy-On-Write) This technique reduces the memory consumption drastically in some situations. It also cuts down the time for allocating new memory on the heap and copying the character sequence. However, this technique may cause problems in threaded systems and it is not used in most modern library implementations.

My recent project is a C++ parser that tokenises its input. Each token contains a file name, line and column numbers. Of course, there are many tokens from the same file. The project uses two different compilers with different library implementations. The memory consumption differed dramatically between the two implementations. Naturally, we wanted the best performance with both implementations.

Strings are used for many purposes. Although a string is a simple concept, there are many ways to use strings, and many types of strings tailored for these usages. You may have many different string types in your project depending on how the strings are used and on the history of your project. If your project uses strings heavily, you may optimise your code by looking at how different string types are used and interact with each other and decide on which type of string is best suited for each usage.