Is there another way to achieve the functionality of std::optional without another object being created?

Question

class ScopedClass {
 public:
  ScopedClass() {
    cout << "constructor called\n";
  }

  ~ScopedClass() {
    cout << "destructor called\n";
  }

  ScopedClass(const ScopedClass &t)
  {
      cout << "copy constructor called\n";
  }

  ScopedClass(ScopedClass &&t)
  {
      cout << "move constructor called\n";
  }
}

std::optional<ScopedClass> check_and_return(bool condition) {
  if (condition == true)
    return std::make_optional(ScopedClass());
  return std::nullopt;
}

int main() {
  auto x = check_and_return(true);
}

I want a single ScopedClass object but ScopedClass() is copied/moved when I enclose it within std::optional. This means that the destructor is called when it's copied/moved and it's being called twice. Once inside check_and_return and once when main ends.

I would like the destructor to be called only when main ends.

Is there a way to achieve this? Or some alternate method not using std::optional?

Answer 1

You can use the in-place overload of std::make_optional rather than the move overload.

std::optional<ScopedClass> check_and_return(bool condition) {
  if (condition == true)
    return std::make_optional<ScopedClass>(); // constructs ScopedClass in place with the arguments ()
  return std::nullopt;
}

Answer 2

And yes there is another option, use std::make_unique/std::unique_ptr. This will not move anything and call constructor and destructor only once.

#include <cassert>
#include <memory>
#include <iostream>
#include <string>

class ScopedClass {
public:
    ScopedClass() {
        std::cout << "constructor called\n";
    }

    ~ScopedClass() {
        std::cout << "destructor called\n";
    }

    ScopedClass(const ScopedClass& t)
    {
        std::cout << "copy constructor called\n";
    }

    ScopedClass(const ScopedClass&& t)
    {
        std::cout << "move constructor called\n";
    }

private:
    std::string some_resource;
};

std::unique_ptr<ScopedClass>  check_and_return(bool condition)
{
    if ( condition )
    {
        return std::make_unique<ScopedClass>();
    }

    return nullptr;
}

int main() 
{
    auto x = check_and_return(true);
}