boost-optional

With Boost I can create an optional in-place with: boost::optional<boost::asio::io_service::work> work = boost::in_place(boost::ref(io_service)); And disengage it with: work = boost::none; With C++14 / experimental support, I can instead construct an optional in-place with: std::experimental::optional<boost::asio::io_service::work> work; work.emplace(boost::asio::io_service::work(io_service)); But I'm at a loss for how to disengage it... work = std::experimental::nullopt; should disengage work . The library fundamental TS specifies in [optional.nullopt]: The struct nullopt_t is an empty

It seems to me there should be four variants of boost::optional optional<Foo> => holds a mutable Foo and can be reassigned after initialization optional<Foo const> const => holds a const Foo and can't be reassigned after initialization optional<Foo> const => (should?) hold a mutable Foo but can't be reassigned after initialization optional<Foo const> => (should?) hold a const Foo and can be reassigned after initialization The first 2 cases work as expected. But the optional<Foo> const dereferences to a const Foo, and the optional<Foo const> doesn't allow reassignment after initialization (as

What should I do to initialize boost::optional< T > if underlying type T is non-default constructible, non-copyable/moveable, but one's instance still can exist? Is it forbidden for boost::optional by any semantic reasons to have some member function like template< typename... Args > boost::optional< T >::construct(Args && ...args) , that delivers all the arguments to in-place operator new to construct the object entirely (for non-ref type T )? Variant is to have non-member function like std::make_shared< T > . It seems to me, that my problem can be solved by means of using of std::unique_ptr

How I can prevent the last line of this code from compiling? #include <boost/optional.hpp> int main() { typedef boost::optional<int> int_opt; int_opt opt = 0; bool x = opt; // <- I do not want this to compile } The last line doesn't examine opt 's contained int value, but instead compiles as a type conversion to bool, and doesn't seem to be what the user intended. The safe bool idiom seems to be relevant here? The whole point of boost::optional is to enable code like this: void func(boost::optional<int> optionalArg) { if (optionalArg) { doSomething(*optionalArg); } } So the implicit conversion