id,summary,reporter,owner,description,type,status,milestone,component,version,severity,resolution,keywords,cc
10399,Breaking change in Boost.Optional,Dean Michael Berris,akrzemi1,"Suppose I have the following types:

{{{#!c++
    struct container {
      boost::optional<uint16_t> optional() const {
        return value_;
      }
     private:
      boost::optional<uint16_t> value_;
    };

    struct value_wrapper {
      value_wrapper(const container& c) : c_(c) {}
      operator uint16_t () { return 1; }
      operator boost::optional<uint16_t>() { return c_.optional(); }
     private:
      const container& c_;
    };
}}}

And that I have the following function:

{{{#!c++
    value_wrapper value(const container& c) {
      return value_wrapper(c);
    }
}}}

The following used to work in MSVC 2010:

{{{#!c++
    container c;
    // leave c.value_ alone.
    boost::optional<uint16_t> some_value =
      value(c);
    assert(!some_value);
}}}

Now with Boost 1.56, this breaks because the constructor for
some_value from a temporary optional is now marked explicit.

What is the work-around for the previous behavior to be regained? All
the following changes cause the assertion to fail:

{{{#!c++
    boost::optional<uint16_t> some_value(value(c));
    assert(!some_value);  // some_value's constructor will use the
    uint16_t conversion operator, therefore some_value == 1

    boost::optional<uint16_t> some_value =
    static_cast<boost::optional<uint16_t> >(value(c));
    assert(!some_value);  // same problem as above, 
                          // the temporary created will favor
                          // the uint16_t conversion operator
}}}

Help?

PS. For better context, see
https://github.com/cpp-netlib/cpp-netlib/blob/0.11-devel/boost/network/protocol/http/algorithms/linearize.hpp#L145",Bugs,closed,Boost 1.58.0,optional,Boost 1.54.0,Regression,wontfix,optional regression,