Избегать временного использования boost:: optional

boost:: дополнительная поддержка in_place, например:

#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));
}

Как только у нас есть инициализированный fooOpt, есть ли способ присвоить ему новый Foo без создания временного?

Что-то вроде:

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

Спасибо!

Ответ 1

подталкивание:: опциональный

#include <boost/optional.hpp>

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

Мы также можем показать (через код), что это создание объекта на месте, сделав Foo наследовать от 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 (в конечном итоге...)

В итоге мы получим доступ к std::optional. Этот тип будет реализовывать метод emplace(), который также будет реализовывать конструкцию на месте.

#include <optional>

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

boost:: optional (скоро...)

В версии 1.56.0 boost::optional также реализует метод emplace(), о котором я говорил для std:: optional. Итак, посмотрим, что:

#include <boost/optional.hpp>

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

Ответ 2

Документированный интерфейс не поддерживает это.

Однако, если вы знаете, что никто не расширяет boost::optional, я считаю, что это может быть технически обоснованным:

template<typename T, typename... Us>
void emplace_replace( boost::optional<T>& target, Us&&... us ) {
  target.~boost::optional<T>();
  try {
    new (&target) boost::optional<T>( boost::in_place( std::forward<Us>(us)...) );
  } catch(...) {
    new (&target) boost::optional<T>();
    throw;
  }
}

Здесь мы уничтожаем target, а затем создаем новую boost::optional<T> на месте с построением места. Конструкция try - catch должна сделать большую throw во время построения безопасной: если она выбрасывается, вы получите пустой optional.

Это, естественно, ведет себя иначе, чем ожидается operator=.

В 1.55 (и, возможно, раньше?) есть недокументированный operator=, который принимает Expr, который поддерживает boost::in_place и boost::in_place<T>. Подробнее см. Комментарий @sharth.

Мое быстрое чтение указывает, что типизированный inplace factory с помощью этого метода может иметь недостаточную защиту:

boost::optional<int> test;
// test = boost::in_place<double>( 3 ); // <-- very dangerous
test = boost::in_place( 3 ); // safe
test = boost::in_place( 3.0 ); // safe

Если тип передается непосредственно в in_place<?>, он может генерировать typed_in_place_factory, которые являются опасными (они делают переданный тип и не проверяют, что он совместим). Поэтому не передавайте никакие типы в boost::in_place.

Это (от чтения источника) делает что-то похожее на мой код destroy/restore, за исключением того, что он делает это без разрушения всего optional и просто уничтожает сохраненные данные и делает его неинициализированным.

В boost 1.56b1 в boost::optional добавлен emplace. Он делает что-то похожее на обе вышеупомянутые операции. (через @AkiraTakahashi)

std::optional Представленные мной предложения включали функцию-член .emplace( Us&&... ), которая напрямую поддерживает замену emplace.

Ответ 3

Как только вы это знаете, вы можете создать обычную ссылку:

optional<Foo> optFoo = ....;
Foo &foo = *optFoo;
foo.x = 3;
foofun(foo);
foo = Foo();