SOURCE Eric Niebler wrote:

>  [...redefining NULL breaks things...]
>  <>struct foo { foo(void*) {} };
>  void bar(foo f) {}
>  void baz() {
>  bar(NULL);
>  }
> 
>  Works with NULL as 0, fails with NULL as null because it needs two
>  user-defined conversions.
> 
>  Redefining NULL is a career-limiting move. Don't do it.

Alright, I concede that I shouldn't redefine a standard macro.  :-P  
Interesting example by the way... hadn't thought of that.  Would be nice 
if there was a way around it.  I find the upper limit on user defined 
implicit conversions frustrating.  This limit has already thwarted my 
plan to make a smart reference type which only locks the contained 
instance while being implicitly converted to the raw reference type.  It 
would have worked something like:

template < typename Type > 
struct Ref
{
    struct InternalRef
    {
        Lock my_lock;
        operator Type & (  );
    };
    operator InternalRef (  );
};

This was planned to work similar to the locking pointer idiom:

template < typename Type > 
struct Ptr
{
    struct InternalPtr
    {
        Lock my_lock;
        Type * operator ->  (  );
    };
    InternalPtr * operator ->  (  );
};

But sadly, the locking reference idea requires two implicit user defined 
conversions.  And I can't exactly overload the '.' operator.  *sigh*  
Why does the C++ language have to ban such potentially fun things as 
infinite implicit conversion chains and overloading the dot operator?

-Jason


_______________________________________________
Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost