Re: best efficient and readable way to concatenate strings (or the best trade-offs)

From:

Alan Johnson <awjcs@yahoo.com>

Newsgroups:

comp.lang.c++

Date:

Mon, 18 Jun 2007 14:08:11 -0700

Message-ID:

<f56s7s$j4r$1@aioe.org>

Diego Martins wrote:

Since C++ (and STL) have many ways to do string concatenation, I want
to hear (read) from you how you do to concatenate strings with other
strings and other types. The approaches I know are:

-- ostringstream
this does the job well, but:
* all types involved have to support operator<<
* we will lose some readibility in the code because we will always
have to create a temp object to do the concatenation

int n;
float x;
...
ostringstream temp;
temp << "we bought " << n << " items at " << x << " price";
notebook.add(temp.str());
// three liner :(

-- string::operator+
most advantage is we can built all the string using a one liner and
passing the result to string const &, but:
* we have to ensure all members are of string type
* to achieve that, we can use boost::lexical_cast or custom functions
to convert our types/classes to string

int n;
float x;
...
notebook.add("we bought " + toString(n) + " items at " + toString(x) +
" price");
// one liner!! :)

(but is there actually a gain doing that?)

and we have to implement toString(). which way is better?
lexical_cast? ostringstream? overloading (or specializing) for each
involved types? (ints and floats can be converted faster using some
hacks)

-- ostringstream wrapped in a (family) of functions
this technique combines the stream versatility with the oneliner
concatenation thing, but without RVO, I am not sure we will gain
anything:

int n;
float x;
...
notebook.add(concat("we bought ",n," items at ",x," price"));
// one liner!! :)

template<typename A, typename B, typename C, typename D>
string concat(A a, B b, C c, D d) {
  ostringstream temp;
  temp << a << b << c << d;
  return temp.str();
}

this works, but one does not need to be a genius to figure out we have
to define a family of concat functions to handle the different number
of parameters

any ideas?

thanks!!!

Diego
HP

I'm a fan of classes like the following:
#include <sstream>
#include <string>

class concat
{
public:
     template <typename T>
     explicit concat(const T & t)
     {
         m_out << t ;
     }

     template <typename T>
     concat & operator()(const T & t)
     {
         m_out << t ;
         return *this ;
     }

     std::string str() const
     {
         return m_out.str() ;
     }
private:
     std::ostringstream m_out ;
} ;

#include <iostream>

int main()
{
     int n = 4 ;
     float x = .99 ;
     std::string test = concat("We bought ")(n)(" items at ")(x)("
price").str() ;
     std::cout << test << std::endl ;
}