Perfect pass-through

I'm thinking about a problem which has some similarity with perfect forwarding, but where the function argument is not passed to a called function, but returned. This is why I call it "perfect pass-through".

The problem is the following:

Say we have a function which takes an object by reference (and possibly some extra arguments), modifies that object, and returns the modified object. The best-known example of such functions are probably operator<< and operator>> for iostreams.

Let's use iostreams as example, because it allows to nicely show what I'm after. For example, one thing which one would sometimes like to do is:

std::string s = (std::ostringstream() << foo << bar << baz).str();

Of course that doesn't work, for two reasons:

std::ostringstream() is an rvalue, but operator<< takes an lvalue as first argument
operator<< returns an ostream& (well, at least for the standard ones actually a basic_ostream<CharT, Traits>& where CharT and Traits are deduced from the first argument).

So let's assume we want to design the insertion operator so that the above works (you obviously can't do that for the existing operators, but you can do that for your own classes). Obviously the solution should have the following traits:

The first argument can accept either an lvalue or an rvalue.
The return type should be the same type as passed in. But of course it should still only accept ostreams (i.e. classes derived from an instantiation of basic_ostream).

While in this specific use case it isn't needed, I want to add a third requirement:

If the first argument is an rvalue, so is the returned value, otherwise an lvalue is re

c++ c++11

Edit Report

std::ostringstream() is an rvalue, but operator<< takes an lvalue as first argument

There's a generic inserter to take rvalue streams, but it returns a basic_ostream<charT, traits>&:

template <class charT, class traits, class T>
  basic_ostream<charT, traits>&
  operator<<(basic_ostream<charT, traits>&& os, const T& x);

To work correctly for your example it would have to return the derived type of the stream (std::ostringstram).

Is the output operator as I wrote it indeed working as expected (and fulfilling all the requirements I gave)? Or could it fail in unexpected ways or have other unexpected consequences? Especially: Is my use of std::forward correct here?

Your code looks correct to me.

Is there an easier way to meet the requirements?

Your code looks similar to the code I wrote to solve this problem (see below).

Assuming this is indeed correct and the simplest way to do it: Do you consider it a good idea to do that, or would you advice against it (both specifically for stream output as in my example, and as a more general scheme for passing objects through functions)?

The idiom looks fine to me.

In libc++ I defined the rvalue ostream inserter like the following (as an extension). I made an attempt to get it standardized but it was late and the committee was understandably not in the mood for more thrashing:

template <class _Stream, class _Tp>
inline
typename enable_if
<
    !is_lvalue_reference<_Stream>::value &&
    is_base_of<ios_base, _Stream>::value,
    _Stream&


                        
                        
                            answered 2012-01-11T22:59:11.930

1 Answer

Your Answer