Prevent the creation of temporary objects

Question

I have the same question that was asked over here five years ago: Disallowing creation of the temporary objects

The reason I am asking it again is that I am specifically interested in C++11 and C++14 techniques for preventing the construction of temporaries.

One idea is to use "rvalue reference for *this":

class ScopedLock
{
public:
  void enable() && = delete;

  void enable() &
  {
    is_enabled = true;
  }

  ~ScopedLock()
  {
    if (!is_enabled) {
      std::cerr << "ScopedLock misuse." << std::endl;
      std::terminate();
    }
  }

private:
  bool is_enabled = false;
};



int main()
{

  // OK
  ScopedLock lock;
  lock.enable();

  // Compilation error.
  ScopedLock().enable();

  // std::terminate
  ScopedLock();

  // std::terminate
  ScopedLock lock;

  std::cout << "Y" << std::endl;
}

Perhaps there is a better way?

If you write `void enable() && = delete;` that actually prevents things like `ScopedLock().enable();` from compiling. It doesn't, however, prevent `ScopedLock()` from compiling. — R. Martinho Fernandes, Apr 17 '14 at 10:14
If it was possible to add an rvalue reference qualifier to the destructor, the problem would have been solved. But as far as I know, that is not possible. — Petter, Apr 17 '14 at 10:24
`templatetypename std::decay::type& as_lvalue(T&&t){return t;}` then `as_lvalue( ScopedLock{} ).enable();` -- so the above does not work. — Yakk - Adam Nevraumont, Apr 17 '14 at 12:50
Yakk: that doesn’t matter. The purpose is avoiding *accidental* mistakes. — Petter, Apr 17 '14 at 14:24
As an XY-problem, you can combine the lock with the locked data. Only provide access to the data via an instance of the lock class. — dyp, Apr 17 '14 at 14:51

score 1 · Accepted Answer · edited May 23 '17 at 10:26

Here are C++11 versions of two great answers to the same question. I don't deserve much credit for this, so consider voting for the original answers instead.

user1773602's answer

The idea is defining a deleted function with de same name as the class:

class ScopedLock {
    // ...  
};

void ScopedLock(...) = delete;

The usage is unusual and this might be (very?) inconvenient:

  class ScopedLock a; // OK             :-| but requires keyword 'class'
  ScopedLock b;       // Compiler error :-(
  ScopedLock();       // Compiler error :-)

Johannes Schaub - litb's answer

If you don't mind having a runtime error (like the OP seems to do) rather than a compile time error then you can try this.

The basic idea is that a temporary bound to an argument of ScopedLock's constructor will be destroyed before or after the ScopedLock object depending on whether the later is a temporary or not.

class ScopedLock {

  bool flag_ = true;

  struct Flag {
    bool* flag;
    ~Flag() {
      *flag = false;
    }
  };

public:

  ScopedLock(Flag&& f = Flag()) {
    f.flag = &flag_;
  }

  ~ScopedLock() {
    if (flag_) {
      std::cerr << "ScopedLock misuse\n.";
      std::terminate();
    }
  }

};

With this, we have

ScopedLock a; // OK
ScopedLock(); // Runtime error

Prevent the creation of temporary objects

1 Answers1

Linked