{"id":110527,"date":"2024-11-15T07:00:00","date_gmt":"2024-11-15T15:00:00","guid":{"rendered":"https:\/\/devblogs.microsoft.com\/oldnewthing\/?p=110527"},"modified":"2024-11-16T09:44:47","modified_gmt":"2024-11-16T17:44:47","slug":"20241115-00","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/oldnewthing\/20241115-00\/?p=110527","title":{"rendered":"How do I put a non-copyable, non-movable, non-constructible object into a std::optional<\/CODE>?"},"content":{"rendered":"

Last time, we wondered how you could put an object into a std::optional<T><\/code> if T<\/code> is not copyable, not movable, and not constructible<\/a>. You typically run into this case when T<\/code> is an object that comes from a factory method rather than a constructor.<\/p>\n

For expository purposes, say we have a Widget<\/code> that can be created inside a region or outside a region. One possible design would be to have a constructor that takes a bool<\/code> that say whether to go inside or outside.<\/p>\n

struct Widget\r\n{\r\n    Widget(Region const& region, bool inside);<\/span>\r\n\r\n    Widget(Widget const&) = delete;\r\n    Widget(Widget &amp&) = delete;\r\n    Widget& operator=(Widget const&) = delete;\r\n    Widget& operator=(Widget &amp&) = delete;\r\n};\r\n<\/pre>\n
I’m not a fan of this design because you have to remember what that final bool<\/code> means.<\/p>\n
Widget widget(region, true); \/\/ what does \"true\" mean?\r\n<\/pre>\n
Does that true<\/code> mean “initially enabled”? Does it mean “inside”? Does it mean “outside”?<\/p>\n
To remove ambiguity, we can switch to factory methods.<\/p>\n
struct Widget\r\n{\r\n    Widget() = delete;\r\n    Widget(Widget const&) = delete;\r\n    Widget(Widget &amp&) = delete;\r\n    Widget& operator=(Widget const&) = delete;\r\n    Widget& operator=(Widget &amp&) = delete;\r\n\r\n    static Widget CreateInside(Region const& region);\r\n    static Widget CreateOutside(Region const& region);\r\nprivate:\r\n    \u27e6 ... \u27e7\r\n};\r\n<\/pre>\n
Okay, so how can we put a Widget<\/code> inside a std::optional<Widget><\/code>? All of our tools for putting an object into an optional<\/code> are failing us. We can’t use emplace<\/code>: That will try to construct the Widget<\/code> from the thing we passed to emplace, but Widget<\/code> is not constructible!<\/p>\n
The trick is that the std::optional<\/code> constructor and assignment operator create the T<\/code> as if by non-list-initialization. This means that implicit conversion operators are in play!<\/p>\n
struct WidgetInsideRegionCreator\r\n{\r\n    WidgetCreator(Region const& region) : m_region(region) {}\r\n    operator Widget() { return Widget::CreateInside(m_region); }\r\n    Region const& m_region;\r\n};\r\n\r\nvoid sample(Region const& region)\r\n{\r\n    \/\/ construct with a Widget value\r\n    std::optional<Widget> o(WidgetInsideRegionCreator(region));\r\n\r\n    \/\/ or place a Widget into the optional\r\n    o.emplace(WidgetInsideRegionCreator(region));\r\n}\r\n<\/pre>\n
The idea here is that we create a helper object, the Widget\u00adInside\u00adRegion\u00adCreator<\/code>, which supports an implicit conversion to Widget<\/code> via the factory method. The Widget<\/code> can then be initialized from the helper object by conversion. The return value from the conversion operator is placed directly in the optional<\/code>‘s Widget<\/code> thanks to mandatory copy elision.<\/p>\n
Okay, now that we know what to do, we can generalize it, so you don’t have to create dozens of tiny little creator classes.<\/p>\n
template<typename F>\r\nstruct EmplaceHelper\r\n{\r\n    EmplaceHelper(F&& f) : m_f(f) {}\r\n    operator auto() { return m_f(); }\r\n    F& m_f;\r\n};\r\n\r\nvoid sample(Region const& region)\r\n{\r\n    \/\/ construct with a Widget value\r\n    std::optional<Widget> o(\r\n        EmplaceHelper([&] {\r\n            return Widget::CreateInside(region);\r\n        }));\r\n\r\n    \/\/ or place a Widget into the optional\r\n    o.emplace(EmplaceHelper([&] {\r\n            return Widget::CreateInside(region);\r\n        }));\r\n}\r\n<\/pre>\n
This trick works even if the factory method belongs to another object.<\/p>\n
struct WidgetFactory\r\n{\r\n    Widget CreateInside(Region const& region) const;\r\n};\r\n\r\nvoid sample(WidgetFactory const& factory,\r\n            Region const& region)\r\n{\r\n    \/\/ construct with a Widget value\r\n    std::optional<Widget> o(\r\n        EmplaceHelper([&] {\r\n            return factory.CreateInside(region);\r\n        }));\r\n\r\n    \/\/ or place a Widget into the optional\r\n    o.emplace(EmplaceHelper([&] {\r\n            return factory.CreateInside(region);\r\n        }));\r\n}\r\n<\/pre>\n
If you don’t like lambdas, you can try  invoke-oriented programming<\/a>.<\/p>\n
template<typename F, typename... Args>\r\nstruct EmplaceHelper\r\n{\r\n    EmplaceHelper(F&& f, Args&&... args)\r\n        : m_f(f), m_args((Args&&)args...) {}\r\n    operator auto()\r\n        { return std::apply(m_f, m_args); }\r\n    F& m_f;\r\n    std::tuple<Args&&...> m_args;\r\n};\r\n\r\ntemplate<typename F, typename... Args>\r\nEmplaceHelper(F&&, Args&&...) -> EmplaceHelper<F, Args...>;\r\n\r\nvoid sample(WidgetFactory const& factory,\r\n            Region const& region)\r\n{\r\n    \/\/ construct with a Widget value\r\n    std::optional o(\r\n        EmplaceHelper(Widget::CreateInside, region));\r\n\r\n    \/\/ or place a Widget into the optional\r\n    o.emplace(EmplaceHelper(&WidgetFactory::CreateInside,\r\n                            factory, region));\r\n\r\n    \/\/ lambdas still work\r\n    o.emplace(EmplaceHelper([&] {\r\n            return factory.CreateInside(region);\r\n        }));\r\n}\r\n<\/pre>\n","protected":false},"excerpt":{"rendered":"
Taking advantage of the conversion operator.<\/p>\n","protected":false},"author":1069,"featured_media":111744,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[25],"class_list":["post-110527","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-oldnewthing","tag-code"],"acf":[],"blog_post_summary":"
Taking advantage of the conversion operator.<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/110527","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/users\/1069"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/comments?post=110527"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/posts\/110527\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media\/111744"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/media?parent=110527"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/categories?post=110527"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/oldnewthing\/wp-json\/wp\/v2\/tags?post=110527"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}