| Home | Libraries | People | FAQ | More

### Optional data members

Suppose we want to implement a lazy load optimization. This is because we do not want to perform an expensive initialization of our `Resource` until (if at all) it is really used. We can do it this way:

    class Widget
    {
      mutable boost::optional<const Resource> resource_;

    public:
      Widget() {}

      const Resource& getResource() const // not thread-safe
      {
        if (resource_ == boost::none)
            resource_.emplace("resource", "arguments");

        return *resource_;
      }
    };

`optional`'s default constructor creates an uninitialized optional. No call to `Resource`'s default constructor is attempted. `Resource` doesn't have to be `DefaultConstructible`. In function `getResource` we first check if `resource_` is initialized. This time we do not use the contextual conversion to `bool`, but a comparison with `boost::none`. These two ways are equivalent. Function `emplace` initializes the optional in-place by perfect-forwarding the arguments to the constructor of `Resource`. No copy- or move-construction is involved here. `Resource` doesn't even have to be `MoveConstructible`.

| Note
Function `emplace` is only available on compilers that support rvalue references and variadic templates. If your compiler does not support these features and you still need to avoid any move-constructions, use In-Place Factories.