Joining a Sequence of Strings

Problem

Given a sequence of strings, such as output from Example 4-10, you want to join them together into a single, long string, perhaps with a delimiter.

Solution

Loop through the sequence and append each string to the output string. You can handle any standard sequence as input; Example 4-13 uses a vector of strings.

Example 4-13. Join a sequence of strings

#include 
#include 
#include 

using namespace std;

void join(const vector& v, char c, string& s) {

 s.clear( );

 for (vector::const_iterator p = v.begin( );
 p != v.end( ); ++p) {
 s += *p;
 if (p != v.end( ) - 1)
 s += c;
 }
}

int main( ) {

 vector v;
 vector v2;
 string s;

 v.push_back(string("fee"));
 v.push_back(string("fi"));
 v.push_back(string("foe"));
 v.push_back(string("fum"));

 join(v, '/', s);

 cout << s << '
';
}

 

Discussion

Example 4-13 has one technique that is slightly different from previous examples. Look at this line:

for (vector::const_iterator p = v.begin( );

The previous string examples simply used iterators, without the "const" part, but you can't get away with that here because v is declared as a reference to a const object. If you have a const container object, you can only use a const_iterator to access its elements. This is because a plain iterator allows writes to the object it refers to, which, of course, you can't do if your container object is const.

I declared v const for two reasons. First, I know I'm not going to be modifying its contents, so I want the compiler to give me an error if I do. The compiler is much better at spotting that kind of thing than I am, especially since a subtle syntactic or semantic error can cause an unwanted assignment. Second, I want to advertise to consumers of this function that I won't do anything to their container, and const is the perfect way to do that. Now, I just have to create a generic version that works on multiple character types.

Just as in Recipe 4.6, making join generic with a function template is easy. All you have to do is change the header to be parameterized on the type of character, like this:

template
void joing(const std::vector >& v, T c,
 std::basic_string& s)

But vectors may not be your only input. You may be saddled with the task of joining an array of C-style strings. C++ strings are preferable to C-style strings, so if you have to do this, join them into a C++ string. Once you've done that, you can always retrieve a C-style version by calling string's c_str member function, which returns a const pointer to a null-terminated character array.

Example 4-14 offers a generic version of join that joins an array of character arrays into a string. Since the new, generic version is parameterized on the character type, it will work for narrow or wide character arrays.

Example 4-14. Joining C-style strings

#include 
#include 

const static int MAGIC_NUMBER = 4;

template
void join(T* arr[], size_t n, T c, std::basic_string& s) {
 s.clear( );

 for (int i = 0; i < n; ++i) {
 if (arr[i] != NULL)
 s += arr[i];
 if (i < n-1)
 s += c;
 }
}

int main( ) {
 std::wstring ws;

 wchar_t* arr[MAGIC_NUMBER];

 arr[0] = L"you";
 arr[1] = L"ate";
 arr[2] = L"my";
 arr[3] = L"breakfast";

 join(arr, MAGIC_NUMBER, L'/', ws);


}