使用ostringstream的奇怪行为

Question

I was trying to think of a clever way to concatenate various things into a single string argument for a function without having to use an ostringstream explicitly. I thought of:

#define OSS(...) \
  dynamic_cast<std::ostringstream const&>(std::ostringstream() << __VA_ARGS__).str()

However, given:

void f( string const &s ) {
  cout << s << endl;
}

int main() {
  char const *const s = "hello";

  f( OSS( '{' << s << '}' ) );

  ostringstream oss;
  oss << '{' << s << '}';
  cout << oss.str() << endl;
}

it prints when run:

123hello}
{hello}

where 123 is the ASCII code for } . Why does using the macro get it wrong?

FYI: I'm currently using g++ 4.2.1 on Mac OS X as part of Xcode 3.x.

---

Solution I'm now using

class string_builder {
public:
  template<typename T>
  string_builder& operator,( T const &t ) {
    oss_ << t;
    return *this;
  }

  operator std::string() const {
    return oss_.str();
  }

private:
  std::ostringstream oss_;
};

#define BUILD_STRING(...) (string_builder(), __VA_ARGS__)

using namespace std;

void f( string const &s ) {
  cout << s << endl;
}

int main() {
  char const *const s = "hello";

  f( BUILD_STRING( '{', s, '}' ) );
}

Answer 1

std::ostringstream() is temporary which thus can be bound only to const references. Standalone operator<< (which take non const references as first argument) aren't considered and only the member one are. The best match in these for a char is converting the char to int.

This problems occurs often with string literals whose address is then displayed.

To solve the problem, the trick is to find a way to transform the temporary in a reference. The member operator<< s do that, but only the one for manipulator does it without side effect and only if the manipulator is a noop -- flush could be used. The members flush and write are also candidates. So for instance

#define OSS(...) \
    dynamic_cast<std::ostringstream const&>(std::ostringstream().flush() << __VA_ARGS__).str()

Answer 2

A better thread-safe solution without involving the cumbersome macro.

The original call to function is this:

f( OSS( '{' << s << '}' ) );

How about if the call is just this:

 f(stringbuilder() << '{' << s << '}' ); 

where stringbuilder is implemented as:

struct stringbuilder
{
   std::ostringstream ss;
   template<typename T>
   stringbuilder & operator << (const T &data)
   {
        ss << data;
        return *this;
   }
   operator string() { return ss.str(); }
};

void f( string const &s ) {
  cout << s << endl;
}

Test:

int main() {
  char const *const s = "hello";

  f(stringbuilder() << '{' << s << '}' );

}

Output:

{hello}

Online Demo : http://ideone.com/QHFf4