23

I have a use case that my object must not be copied in any way. I have written an exaggerated complete list of copy constructor and copy assignment operator deletions below. There are so many of them that I can't make sure which ones to use, and sometimes this makes me paranoid. I don't have to write them all in my code, do I? So, in order to prevent object copying of any kind, which of them should I use?

        MyClass             (       MyClass &)  = delete;
        MyClass             (const  MyClass &)  = delete;
        MyClass             (       MyClass &&) = delete;
        MyClass             (const  MyClass &&) = delete;
        MyClass    operator=(       MyClass &)  = delete;
        MyClass    operator=(const  MyClass &)  = delete;
const   MyClass    operator=(       MyClass &)  = delete;
const   MyClass    operator=(const  MyClass &)  = delete;
        MyClass &  operator=(       MyClass &)  = delete;
        MyClass &  operator=(const  MyClass &)  = delete;
const   MyClass &  operator=(       MyClass &)  = delete;
const   MyClass &  operator=(const  MyClass &)  = delete;
        MyClass && operator=(       MyClass &)  = delete;
        MyClass && operator=(const  MyClass &)  = delete;
const   MyClass && operator=(       MyClass &)  = delete;
const   MyClass && operator=(const  MyClass &)  = delete;
        MyClass    operator=(       MyClass &&) = delete;
        MyClass    operator=(const  MyClass &&) = delete;
const   MyClass    operator=(       MyClass &&) = delete;
const   MyClass    operator=(const  MyClass &&) = delete;
        MyClass &  operator=(       MyClass &&) = delete;
        MyClass &  operator=(const  MyClass &&) = delete;
const   MyClass &  operator=(       MyClass &&) = delete;
const   MyClass &  operator=(const  MyClass &&) = delete;
        MyClass && operator=(       MyClass &&) = delete;
        MyClass && operator=(const  MyClass &&) = delete;
const   MyClass && operator=(       MyClass &&) = delete;
const   MyClass && operator=(const  MyClass &&) = delete;
hkBattousai
  • 10,583
  • 18
  • 76
  • 124

2 Answers2

52

You only need to mark a single copy constructor and copy assignment operator as delete. The presence of the copy versions will prevent the implicit-declaration of the move constructor and move assignment operator, and declaring one form of a copy special member function suppresses the implicit-declaration of other forms.

MyClass (const MyClass&) = delete;
MyClass& operator= (const MyClass&) = delete;

Note that post-C++11, implicit-definition of the assignment operator as defaulted is deprecated and it should instead be defined as deleted.

TartanLlama
  • 63,752
  • 13
  • 157
  • 193
  • 4
    Just a very slight nitpick, and I might be wrong. Isn't the *definition* deprecated, not the *declaration*? They are always declared, but their definition is deleted. But I'm not a very good language lawyer. – luk32 Nov 18 '15 at 10:12
  • @luk32 ah, you are correct, it should instead be implicitly-declared and defined as deleted, (`[class.copy]/18`), thanks. – TartanLlama Nov 18 '15 at 10:15
9

copy constructor

MyClass             (const  MyClass &)  = delete;

assignement operator

MyClass &  operator=(const  MyClass &)  = delete;

These are the only copy constructors ans copy assignement operators implicitly defined.

Brahim
  • 808
  • 1
  • 8
  • 17
  • 2
    `operator=` isn't a constructor; and in general other constructors may be implicitly defined - but the presence of user-defined `MyClass (const MyClass &)` suppresses the other constructors. – M.M Nov 18 '15 at 09:58
  • 4
    Your "solution" is good but answer is actually wrong. The proper reasoning is that all assignment operators and constructors are implicitly defined unless, among other reasons, you define one by hand. Deletion counts as definition for this purpose. – luk32 Nov 18 '15 at 10:02