Re: Bad use of stringstream temporary?
Hi Group!
First off, thanks to Victor and the other respondents for
sorting this out for me.
I have a follow-up question concerning this issue and the
draft c++0x standard.
On Mar 24, 7:27 pm, Victor Bazarov <v.baza...@comcast.invalid> wrote:
On 3/24/2011 5:50 PM, K. Frank wrote:
[..]
(I will admit that I've now taken a stroll through some alleys and
byways
I hadn't intended to tour.)
I have set myself a homework problem:
<< loophole.cpp>>
...
Does this correctly illustrate your explanation? As it stands, the
program fails to compile, with the error indicated in the comment.
Yes, that's the expanded (and functional) version of what my 'foo' and
'bar' intended to show.
...
V
I have a copy of the draft standard, but I don't have a
copy of the current standard, so I can't make a detailed
comparison to see what changed.
However, as I understand it, under the new draft, the issue
with operator<< is still the same: operator<< for char* is
still a free function, while operator<< for void* is a
member function. But it appears that the restriction about
binding a temporary to a non-const reference may have been
relaxed.
As Kai pointed out in the MinGW thread, section 12.2.5 of
the draft standard talks about binding temporaries to
references without imposing the restriction that the
references be const. Our reading suggests that the basic
example:
std::string s1 =
dynamic_cast<std::stringstream&>(std::stringstream() << "abc").str();
is legal under the draft standard and should print out
"abc" (rather than the pointer value).
Now the conundrum.
(First, I understand that g++ doesn't claim to implement
completely, or even correctly, the draft standard. But
at least it's a start.)
Compiling
std::string s1 =
dynamic_cast<std::stringstream&>(std::stringstream() << "abc").str();
with "g++ -std=c++0x" (version 4.5.2) prints out "abc".
My interpretation is that the draft standard lets the
temporary bind to the ostream& reference argument of the
free function operator<< for char*, so that the call no
longer resolves to the member function operator<< for void*.
So far, so good (I think)...
However, compiling the loophole example:
<< loophole.cpp >>
#include <iostream>
struct Loophole {
Loophole (int i) : i_(i) {}
Loophole &loophole() { return *this; }
int i_;
};
void print_incr_i (Loophole &l) {
l.i_++;
std::cout << "l.i_ = " << l.i_ << std::endl;
}
int main (int argc, char *argv[]) {
print_incr_i (Loophole (99).loophole());
// next line gives: error: invalid initialization of non-const
reference
print_incr_i (Loophole (66));
}
with "g++ -std=c++0x" still gives the compile error:
loophole.cpp: In function 'int main(int, char**)':
loophole.cpp:17:30: error: invalid initialization of non-const
reference of type 'Loophole&' from an rvalue of type 'Loophole'
loophole.cpp:9:6: error: in passing argument 1 of 'void
print_incr_i(Loophole&)'
So, the theory was that the draft standard relaxes the
restriction on binding a temporary to a non-const reference
(and that "g++ -std=c++0x" implements this change), and
that's why the stringstream example works. But the
loophole example contradicts this.
How should the two examples (stringstream and loophole)
behave under the draft of the c++0x standard? Is g++
right in both cases (for reasons that I don't understand),
or is something half-baked going on here?
Again, thanks to all for any further insight.
K. Frank