Boost logo

Boost :

From: Ian McCulloch (ianmcc_at_[hidden])
Date: 2005-10-14 15:01:51

Fernando Cacciola wrote:
> Joel de Guzman wrote:


>> The nullability aspect is *besides*
>> the point and has nothing at all to do with the rebinding semantics.
> This is 100% false. Is 100% the opposite.
> Rebinding semantics are there _precisely_ and _only_ to solve a problem
> posed by nullability.
> Let me say that again:
> Rebinding semantics are there _precisely_ and _only_ to solve a problem
> posed by nullability.
> So once again, I ask you to deeply consider nullability and the problem it
> poses on assignment (I hope I don't have to repeat it again), then weight
> my proposed solution (rebinding) with your expectactions. If possible,
> propose a better solution or at least show that you don't think the
> problem is worth a controversial solution like rebinding.

If optional<> is to be useful for references, then it should have the same
semantics that a class acting as a proxy-reference has. ie, if I use
optional<> with a class like

template <typename T>
struct Proxy
   explicit Proxy(T& obj) : my_obj(&obj) {}

   Proxy& operator=(T const& obj) { *my_obj = obj; return *this; }

   // ...

   T* my_obj;

then optional<T&> should act as close to optional<proxy<T> > as possible.
ie., if optional<T&> does something different just because the template
argument is a reference, then there must be a way to replicate that
behaviour with optional<proxy<T> > too. As to what behaviour is most
useful, I am not sure because I have not yet come across a situation where
I wanted an optional<T&> - but I do find the rebinding behaviour

I don't see what nullability per-se has to do with this discussion.


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