c++ problems with temporary ostream objects

Question

I thought to transform this working code:

ofstream outfile("my_file.txt");
copy(v.begin(), v.end(), ostream_iterator<int>(outfile));

into this:

copy(v.begin(), v.end(), ostream_iterator<int>(ofstream("my_file.txt")));

In other words, I use an "anonymous", or unnamed, version of the ofstream object.

Two questions:

(1) Why does the second attempt fail?

(2) Is the second attempt even good stylistically, or is it better in C++ to keep everything explicitly named? I'm coming from a Python background, where objects are created on the fly all the time.

Thanks!!

Because a non-const-reference is required to the constructor of the iterator, and you're passing a temp object, which at-best can be sent to a const-reference parameter only. To answer your second question, code that doesn't compile/work hardly qualifies in the legend of "good style". — WhozCraig, Feb 28 '13 at 01:54
How does the second version fail? Does it compile? If not, what is the error? If so, do you get a run-time error? — Code-Apprentice, Feb 28 '13 at 01:54

score 3 · Answer 1 · edited May 23 '17 at 12:27

The ostream_iterator<T> constructor takes a non-const reference to a stream object, while temporaries can be passed at most as const references (at least in C++03); the rationale for this is well explained in this question.

By the way, here there wasn't much choice about how to pass the stream: a const reference wouldn't have made sense (the ostream_iterator has to modify the stream), and a plain ostream isn't acceptable because it is non-copyable (slicing would kill polymorphism).

In Python you can get away with constructing/passing stuff on the fly because you are always dealing with references to reference-counted (and garbage-collected) objects.

The C++ object semantic is radically different - an object is an object, not a reference; to obtain a semantic similar to Python's you would have to allocate every object dynamically with new and pass them around wrapped in shared_ptr<T>.

is it better in C++ to keep everything explicitly named

Not necessarily - it's perfectly normal to create temporaries, but you must be aware of what you can and cannot do with them, how references affect their lifetime, etc.

+1 In case my support for this wasn't obvious in the comments. — WhozCraig, Feb 28 '13 at 02:00
This was true in C++03. In C++11, you can pass temporaries as non-const *rvalue references*. — Ben Voigt, Feb 28 '13 at 02:00
@BenVoigt: I know, but I still haven't wrapped my head around rvalue references, and I prefer not to talk about stuff I don't know well. — Matteo Italia, Feb 28 '13 at 02:02

score 0 · Answer 2 · answered Feb 28 '13 at 02:01

I get the following error message from my compiler which explains it.

std::ostream_iterator's constructor takes a non const reference. There isn't a version of the constructor that takes a std::ofstream.

Untitled 33.cpp:21: error: no matching function for call to ‘std::ostream_iterator<int, char, std::char_traits<char> >::ostream_iterator(std::ofstream)’
/usr/include/c++/4.2.1/bits/stream_iterator.h:185: note: candidates are: std::ostream_iterator<_Tp, _CharT, _Traits>::ostream_iterator(const std::ostream_iterator<_Tp, _CharT, _Traits>&) [with _Tp = int, _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2.1/bits/stream_iterator.h:181: note:                 std::ostream_iterator<_Tp, _CharT, _Traits>::ostream_iterator(std::basic_ostream<_CharT, _Traits>&, const _CharT*) [with _Tp = int, _CharT = char, _Traits = std::char_traits<char>]
/usr/include/c++/4.2.1/bits/stream_iterator.h:169: note:                 std::ostream_iterator<_Tp, _CharT, _Traits>::ostream_iterator(std::basic_ostream<_CharT, _Traits>&) [with _Tp = int, _CharT = char, _Traits = std::char_traits<char>]

Yes, but there is one taking a `basic_ostream` by reference and `oftream_iterator` derives from `basic_ostream` which should convert. It doesn't convert because an rvalue cannot bind to a non-const lvalue reference. — pmr, Feb 28 '13 at 02:28

score 0 · Answer 3 · answered Feb 28 '13 at 02:22

In C++ we also often construct objects on-the-fly, but issues of ownership need to be minded.

The problem with ostream_iterator<int>(ofstream("my_file.txt")) is that a temporary object is getting passed to a constructor, but the constructed ostream_iterator object doesn't take ownership of the temporary's responsibilities. If the ostream_iterator weren't also a temporary, it would continue to hold an invalid reference at the next line of code.

There are ways around this, by passing to an identity function or by casting. But they generally sacrifice safety, in the sense that if you use such a mechanism on a persistent variable it will create a dangling reference.

When you have several objects linked by references, without a container-contained relationship, current C++ best practice is to use named objects, not temporaries.

If you don't like this, you can choose to use shared pointers more often. That pattern allows the ownership to be shared between several references, with a container being hidden away. But that's not part of iostreams, and as design decision it would be a bit questionable here.

c++ problems with temporary ostream objects

3 Answers3