Brian McNamara <lorgon@cc.gatech.edu> writes:

On Tue, Apr 13, 2004 at 12:26:35AM +1000, Thorsten Ottosen wrote:

...

I think I have found a safe way to bind a temporary to a const reference and cast away the constness.

This means that a temporary can be passed (relatively) safely to an algorithm with a prototype like ... Comments are welcome.

Cute use of compile-time ambiguity to ensure that you don't try to mutate const objects.

Offhand it seems like it is "safe", in the sense of lifetime-of-the-temporary issues.

Seems like this would be more useful. template <class T> T& mutate_rvalue(T& x, int) { return x; } template <class T> T& mutate_rvalue(T const& x, ...) { return const_cast<T&>(x); } // test code #include <string> typedef int yes; typedef char* no; template <class T> yes is_mutable(T&); template <class T> no is_mutable(T const&); std::string x; std::string const y; yes a = is_mutable(mutate_rvalue(x,0)); no b = is_mutable(mutate_rvalue(y,0)); yes c = is_mutable(mutate_rvalue(x+y,0));

What's an example use-case? I don't recall ever needing/wanting this.

Howard Hinnant brought up some cases, during LWG discussion of iterator adaptors, where you might want to mutate an object if you had permission to, for example in some linear algebra you might want to do part of the algorithm in-place. If it was generic code you'd want to take the same liberties with rvalues as with mutable lvalues. -- Dave Abrahams Boost Consulting www.boost-consulting.com

"Thorsten Ottosen" <nesotto@cs.auc.dk> writes:

"David Abrahams" <dave@boost-consulting.com> wrote in message news:uzn9hcgip.fsf@boost-consulting.com... [snip]

...

Seems like this would be more useful.

Perhaps. Do you care to explain why?

It works generically on lvalues and rvalues, so that if someone hands you a function object f, and some_algo is more efficient when it can modify its first argument in-place, you can do some_algo( mutate_rvalue(f(),0), x ); HTH, -- Dave Abrahams Boost Consulting http://www.boost-consulting.com

Thorsten Ottosen wrote:

"David Abrahams" <dave@boost-consulting.com> wrote in message

...

It works generically on lvalues and rvalues, so that if someone hands you a function object f, and some_algo is more efficient when it can modify its first argument in-place, you can do

some_algo( mutate_rvalue(f(),0), x );

yeah, definitely an improvement, although I wish there was some way of putting a static assertion in there. The new error message is a lot worse.

How about this: template<class T> struct cant_mutate_const_values { typedef int type; }; template<class T> struct cant_mutate_const_values<T const> { typedef typename cant_mutate_const_values::error type; }; template<class T> T& mutate_rvalue(T const& x) { return const_cast<T&>(x); } template<class T> T& mutate_rvalue(T& x, typename cant_mutate_const_values<T>::type = 0) { return x; } -- Daniel Wallin

Thorsten Ottosen wrote:

"Daniel Wallin" <dalwan01@student.umu.se> wrote in message news:407BC506.6020209@student.umu.se...

...

How about this:

[snip]

it's better, although I can't compile it on comeau 4.3. gcc and vc7 seems to like it. I'm know sure there can be made a normal boost-hacked implementation that will work nicely on many platforms. We just someone to do it.

OK, this works on comeau: template<class T> struct cant_mutate_const_values { typedef int type; }; template<class T> struct cant_mutate_const_values<T const> { template<class U> struct error {}; typedef typename error<T>::type type; }; template<class T> T& mutate_rvalue(T const& x) { return const_cast<T&>(x); } template<class T> T& mutate_rvalue(T& x, typename cant_mutate_const_values<T>::type = 0) { return x; } -- Daniel Wallin

"Thorsten Ottosen" <nesotto@cs.auc.dk> wrote in message news:c5fdhk$f2n$1@sea.gmane.org... [snip] Doh!

vector<int> vec();

my_copy( my_sort( my_unique( vec() ) ), ostream_iterator<int>( cout ) );

my_copy( my_sort( BOOST_LVALUE( my_unique( BOOST_LVALUE( vec() ) ) ) ), ostream_iterator<int>( cout ) );

instead of

vector<int> temp1( vec() ); vector<int> temp2( my_unique( temp1 ) ); my_copy( my_sort( temp2 ), .... )

br Thorsten

"Vladimir Prus" <ghost@cs.msu.su> wrote in message news:c5g491$ig4$1@sea.gmane.org...

I wish we can get away from BOOST_LVALUE too. The simple approach of:

template<class T> void sort(T t) {}

template<class T> void sort(T& t) {}

does not really work, since there's ambiguity when passing non-const reference

One is a language change like &&. If we had template<class T> void sort(T t) {} template<class T> void sort(T& t) {} template< class T > void sort( const T& t ) wouldn't it be possible to enable/disable certain combination in certain situaltions, so it would just work ? Anyway, my brain has stopped thinking, so I'll better do some homework. br Thorsten