C++Talk.NET

Samee Zahur · Guest

This is a followup to two recent threads in c.l.c++
-
http://groups-beta.google.com/group/comp.lang.c++/browse_thread/thread/532943e5798f58db/e3aa4aac4225190b?q=Mutating+temporaries+author:Samee&rnum=1#e3aa4aac4225190b
-
http://groups-beta.google.com/group/comp.lang.c++/browse_thread/thread/3ae26ddfaf040d62/556029a16ad33bcd?q=Mutating+temporaries+author:Samee&rnum=2#556029a16ad33bcd

It seems that C++ treats temporary objects rather strangely
(to me at least):

- temps of built-in types and enums (or their typedefs) are always
const ... after all, statements such as 1+2=val; wouldn't make sense!

- temps of all other types are mutable if used directly - the
following is legal: myclass().mutatewith(54);
or even myclass()=54;if operator= is defined in myclass.

- the same temps when passed to a function by reference, however,
must be passed as a 'const myclass&', which means if temps are to be
mutated from within the function, a const_cast is needed (or is that
undefined?)

Why does such a discrepency exist? I mean, the whole idea of C++ is to
have user-defined types that act like 'first-class citizens', right?
Even though user-defined temporaries might often have to be mutated -
why can't something like that be done inside a function receiving it by
reference? Restrictions like these often seems to be getting in the way
of const-correctness as far as I see :(

Samee

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.jamesd.demon.co.uk/csc/faq.html ]

illumanus@yahoo.com · Guest

The reason temporaries are not allowed to be passed to functions
accepting arguments by reference has to do with implicit conversions.
Look at the following code:

struct MyString {
....
MyString (char *); // Defines an implicit conversion from char * to
MyString
MyString &toupper(); // Converts our string to uppercase and returns
*this
};

// Some "handy" functions
void toupper(MyString &s) { s.toupper(); };
bool isupper(const MyString &); // Returns true if our string is all
uppercase
MyString make_str() { return "Foo"; };

...

toupper("Foo"); // This will generate an error and should
// It would cause a temporary MyString to be constructed, modified then
destroyed
// Not what the coder probably intends from writing this statement.

if(isupper("Foo")) // This is ok
cout << "Foo";

if(isupper(make_str().toupper()); // This is ok too
cout << "Upper Foo"

This rule is to protect coders. Without this rule you could accidently
generate code that might appear to do something but really does nothing
and does not generate a compile time error.
Hope this helps,
Lance Gatlin

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.jamesd.demon.co.uk/csc/faq.html ]

Me · Guest

It doesn't really come from the constness of builtins. It comes from
the way C treats l-values and the fact that it didn't have const early
on and there was already a lot of code written. Your code touches on a
specific issue so lets take a digression:

T foo()
{
return T();
}

foo() = T();

works for structs/classes, doesn't work for primitives. Note that if T
was a struct/class, you can't do:

foo().i = 50;

The way to protect against this is:

const T cfoo()
{
return T();
}

cfoo() = T();

Now it doesn't work as expected. But note: for primitive types the
top-level const is redundant, so it generates the same function
signature. The problem with your code is that it was constructing a T
using:

T() // similar to foo()

you cannot do:

const T() // would be similar to cfoo()

because there is a space between it (except as an extension in
Microsoft's compiler which allows spaces in certain cases). You can get
around this with either a typedef:

typedef const T cT;

cT()

or with a template helper involving a typedef:

template<class T> struct ident { typedef T type; };

ident<const T>::type()

---
[ comp.std.c++ is moderated. To submit articles, try just posting with ]
[ your news-reader. If that fails, use mailto:std-c++@ncar.ucar.edu ]
[ --- Please see the FAQ before posting. --- ]
[ FAQ: http://www.jamesd.demon.co.uk/csc/faq.html ]

Llewelly · Guest

"Samee Zahur" <samee.zahur (AT) gmail (DOT) com> writes:

Seungbeom Kim · Guest

[email]illumanus (AT) yahoo (DOT) com[/email] wrote:

Samee Zahur · Guest

Seungbeom Kim · Guest

Llewelly wrote: