Can I prevent the assignment of an object?

Question

I want the following type of call to be illegal:

MyClass me; MyClass you; me = you; // how to make this illegal? 

Is it possible?

Answer 1

Declare an assignment statement private:

 class A { private: void operator=(const A&); ... }; 

but they don’t provide an implementation - you will receive a compilation error or link time error message if you try to assign A.

I prefer to use a macro for this. It also prevents copying, while also making the copy constructor private:

 #define CANNOT_COPY( class ) \ private: \ class(const class&); \ void operator=(const class &) \ 

Then I can say things like:

 class A { CANNOT_COPY( A ); ... }; 

which is easy to read and easy to find.

Answer 2

declare the assignment operator as private .

Answer 3

Yes - define a private assignment operator= ( operator= ) or get boost::noncopyable from a convenient class.

Answer 4

Use a constant.

 MyClass const me; MyClass you; me = you; // compilation error 

Answer 5

I use to output my non-copyable classes from a generic noncopyable class. If you are not using boost, I usually use this shortcut:

 class NonCopyable { protected: /** * Protected default constructor */ NonCopyable() {} /** * Protected destructor */ ~NonCopyable() {} private: /** * Private copy constructor */ NonCopyable( const NonCopyable& ); /** * Private assignment operator */ const NonCopyable& operator=( const NonCopyable& ); }; 

Note that neither the copy constructor nor the assignment operators have an implementation.

Answer 6

As in C ++ 11, I understand that the preferred solution is to use the '= delete' construct:

 class MyClass { MyClass (const MyClass&) = delete; // Disable copy constructor MyClass& operator=(const MyClass&) = delete; // Disable assignment ... } 

Then

 MyClass me; MyClass you; me = you; // won't compile 

Answer 7

Other answers are correct here. However, it is important to note that you prohibit only the code you specify. Someone else can come and duplicate their class using memcpy or other strategies.