Boost logo

Boost :

From: David Abrahams (dave_at_[hidden])
Date: 2005-05-09 12:40:52

Daniel Wallin <dalwan01_at_[hidden]> writes:

> David Abrahams wrote:
>> Daniel Wallin <dalwan01_at_[hidden]> writes:
>>>David Abrahams wrote:
>>>>The question is, what should we do about this? It turns out to be
>>>>surprisingly hard to write the declarations of these temporary
>>>>variables so they work in all cases. For example, v had to be a
>>>>const& because in one case index_result<...>::type turned out to be
>>>> char const[4]
>>>>and when the default is used, it's
>>>> double
>>>>with p[value || ...] returning a double rvalue (by value).
>>>Make the user add reference to the Default type instead of
>> I don't fully understand what you're proposing or what it's supposed
>> to address, but I think you might be missing the point. To make it
>> safe to use, ideally
>> index_result<...>::type whatever = p[x | some-expression];
>> would always cause a by-value return from p[...] when some-expression
>> is an rvalue.
> It's perfectly safe for p[...] to always return by reference, even if
> some-expression is an rvalue. The only problem is that it's hard for the
> user to determine if the result should be held by reference or not.

OK, that's one way to look at it: it's perfectly safe for the library
to do X, as long as the user is really careful to do Y when necessary.
I was looking at this from the user's eyes: she'd like the library to
do something that's always safe and never require her to "determine if
the result should be held by reference or not."

> I propose that the user tells index_result<> if the result of the
> default expression should be by reference, so that:
> index_result<.., int>::type whatever = p[x | 0];
> whatever stores a copy of 0 in the default-case, and stores a reference
> to p[x] otherwise.
> int default_ = ...;
> index_result<.., int const&>::type whatever = p[x | default_];
> See what I'm saying now? Am I missing the point?

That's not too bad.

I think we might be able to make it a bit safer by detecting when the
default is a non-const rvalue and having p[...] return by value in
that case. However, that might come at the cost of some efficiency if
the user also happens to use a non-reference variable:

  index_result<.., heavyweight_type>::type = p[x | rvalue_expr() ]

Of course, when it's heavy the user will probably be using || for lazy
defaults, in which case, can we protect her?

Dave Abrahams
Boost Consulting

Boost list run by bdawes at, gregod at, cpdaniel at, john at