Re: anonymous array of strings // ("taking address of temporary"
- how long is temporary valid?)
* Dario Saccavino:
On 11 Feb, 21:06, "Alf P. Steinbach" <al...@start.no> wrote:
Temporaries behave like being constant wrt. to binding to references.
But they're not constant unless they have const type, and in particular,
you can call non-const non-static member functions on a temporary of
class type (unless the type is const), which includes assignment to a
temporary of class type, because operator= is then a member function...
What is the reason for this behaviour?
It seems to me that it breaks the distinction between R-value and L-
value. The following two snippets:
X a, b, c;
a + b = c;
X f(); // extern function
void g()
{
X x;
f() += x;
}
both cause a compile error when X = int, but they become valid (at
least, with all the compilers and libraries that I could test) if I
use X = std::complex<int> or X = std::string. And they both look like
logical errors by the programmer.
Heh heh. :-) It's much worse. Consider
struct S { int v; };
S foo() { return S(); }
int main()
{
foo() = S(); // OK, can change the whole shebang.
foo().v = 0; // Nyet! Can not change part!
}
As it happens both g++ 3.4.4 and msvc 7.1 compile this fine (or rather,
erronously), but Comeau Online 4.3.9 reports for the last assignment
that "expression must be a modifiable lvalue".
Furthermore, as pointed out by some previous threads in this
newsgroup, this behaviour introduces a difference between an operator
declared as a class method and the same operator declared as a global
function;
Good observation. May relate to why operator= can only be defined as a
member function. Bjarne stated somewhere that it was to (my words) keep
some degree of sanity, something you could rely on, and I had difficulty
understanding what that meant, but possibly it could refer to the
discrimination between rvalues and lvalues that a freestanding operator=
would give. Although I still do not quite understand it. Possibly the
rvalue/lvalue distinction doesn't really make sense in C++.
This discussion could possibly benefit from being brought to comp.std.c++.
Except -- that group's temporarily down.
this difference may also lead to bugs that are hard to track
and hard to explain to novice programmers.
What do we gain from this feature?
One example that I remember being mentioned is, for a multi-dimensional
logical array, the ability to define an operator[] that returns a proxy
object that can be assigned to (the first level proxy object would then
itself also provide an operator[], the purpose being to not expose the
logical array's internal memory layout or general implementation).
However, in most real-world cases the proxy object would not need to be
modified by the assignment, so you could define
struct Proxy
{
Proxy const& operator=( SomeElementType const& ) const;
};
So I think perhaps a better example is the stringizer (or more generally
the idea of chaining calls, used e.g. in named arguments idiom),
struct Str
{
std::ostringstream stream;
template< typename T >
Str& operator<<( T const& v ) { stream << v; return *this; }
operator std::string() const { return stream.str(); }
};
void foo( std::string const& ) {}
int main()
{
foo( Str() << "Line " << 42 << "." );
}
Cheers,
- Alf
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?