Рискованный оператор заклинаний?

Question

Я где-то читал, что перегрузка операторов приведения типов рискованна.И у меня есть некоторые segfaults здесь и там.Итак, я расстроил гнездо шершней?Вот мой код:

template <typename Wee>
struct xl_type_proxy_t {

   static_assert( 
       boost::mpl::or_<
       boost::is_same< Wee, WORD > ,
       boost::is_same< Wee, DWORD >
   >::value, "xl_type_proxy: should instantiate correctly" );

   Wee* where_to_drop;

   xl_type_proxy_t( Wee* wtd):
      where_to_drop( wtd )
   {}

   operator Wee() const {
      // Return stuff with state bits cleared
      //return xltypeNil;
      return (*where_to_drop) & 0xAFFF;
   }

   xl_type_proxy_t& operator=( Wee w )
   {
      // Save only the flags that were already in 
      // 'where_to_drop'.
      (*where_to_drop) = (*where_to_drop) & 0x5000;
      // And now over-write the rest
      (*where_to_drop) = (*where_to_drop) | w;
      return *this;
   }
};

...
xl_type_proxy_t< decltype(this->xl) > proxy_xl() 
{
      return xl_type_proxy_t<decltype(this->xl)>( &(this->xl));
}

... // In some places:
proxy_xl() = ... // Some numeric constant 

... // In some others:
if ( proxy_xl() == /* some numeric constant */ ) 
{
    ...
}