c++ - Avoiding temporary when using boost::optional

Question

boost::optional support in_place construction like so:

#include <boost/optional.hpp>
#include <boost/utility/typed_in_place_factory.hpp>

class Foo
{
    int a,b;

  public:
    Foo(int one, int two) : a(one),b(two) {}
};


int main()
{
    boost::optional<Foo> fooOpt(boost::in_place<Foo>(1,3));
}

Once we have an initialized fooOpt, is there a way of assigning a new Foo to it without creating a temporary?

Something like :

fooOpt = boost::in_place<Foo>(1,3);

Thanks!

Answer 1

boost::optional

#include <boost/optional.hpp>

int main() {
    boost::optional<int> x;
    x = boost::in_place(3);
}

We can also show (via code) that this is building the object in-place by making Foo inherit from boost::noncopyable:

#include <boost/optional.hpp>
#include <boost/noncopyable.hpp>

class Foo : boost::noncopyable {
    public:
        Foo(int one, int two) {}
};


int main() {
    boost::optional<Foo> x;
    x = boost::in_place(3, 4);
}

std::optional (eventually...)

Eventually, we will get access to std::optional. This type will implement an emplace() method, that will implement in-place construction as well.

#include <optional>

int main() {
    std::optional<int> x;
    x.emplace(3);
}

boost::optional (soon...)

In version 1.56.0, boost::optional will also implement the emplace() method that I talked about for std::optional. So, let's see that:

#include <boost/optional.hpp>

int main() {
    boost::optional<int> x;
    x.emplace(3);
}