Correct use of `= delete` for methods in classes

Question

Is the following snipplet correct for un-defining all otherwise generated methods and constructors for a class?

struct Picture {

  // 'explicit': no accidental cast from string to Picture
  explicit Picture(const string &filename) { /* load image from file */ }

  // no accidental construction, i.e. temporaries and the like
  Picture() = delete;

  // no copy
  Picture(const Picture&) = delete;

  // no assign
  Picture& operator=(const Picture&) = delete;

  // no move
  Picture(Picture&&) = delete;

  // no move-assign
  Picture& operator=(Picture&&) = delete; // return type correct?
};

This deletes every default compiler implementation and only leaves the destructor, right? Without it the class would be (almost) unusable I guess, but I could delete it as well, correct?

Is the return type Picture& of the move-assign operator=(Picture&&) correct? Does it make a difference if I wrote Picture&& for the return type?

It seems like C++ has really changed a lot in C++0x!, Interesting stuff. — satnhak, Apr 16 '11 at 14:19
it's a clearer syntax then the common practice of hiding those methods in a `private` section, and only *declaring* but not *defining* them. — towi, May 27 '11 at 08:03

score 26 · Accepted Answer · edited Jun 25 '13 at 07:54

In addition to Xeo's answer:

Yes, everything is correct. If you wanted you could eliminate all of the deleted members but the deleted copy constructor and deleted copy assignment and have the same effect:

struct Picture {  // Also ok

  // 'explicit': no accidental cast from string to Picture
  explicit Picture(const string &filename) { /* load image from file */ }

  // no copy
  Picture(const Picture&) = delete;

  // no assign
  Picture& operator=(const Picture&) = delete;
};

The explicit declaration of the copy constructor inhibits the implicit generation of the default constructor, move constructor and move assignment members. Having these members explicitly deleted is a matter of taste. Some will probably see it as good documentation. Others may see it as overly verbose.

Thanks, I overlooked that in the draft text. That saves typing time. I assume I could `= default` them if I wanted them in? — towi, Apr 16 '11 at 17:02
Yes. You can explicitly default them or explicitly delete them. — Howard Hinnant, Apr 17 '11 at 03:44

score 3 · Answer 2 · answered Apr 16 '11 at 14:23

3

Seems fine to me. The return value of operator= must be a normal reference, even if the object is constructed from a rvalue reference. That is because you can't just compile an lvalue (*this) to an rvalue.
And it should take that rvalue reference per non-const Picture& operator=(Picture&&). How would you move from a constant object? ;)

answered Apr 16 '11 at 14:23

Xeo

129,499
52
291
397

Of course, how silly of me. You are right on both accounts. Let me correct it in the question, so the readers do not learn from my faulty example. – towi Apr 16 '11 at 15:27

Correct use of `= delete` for methods in classes

2 Answers2

Linked