Can I prevent object assignment?

I want to ensure that the following type of call is illegal:

MyClass me;
MyClass you;
me = you; // how to make 开发者_如何学编程this illegal?

Is it possible?

---

Declare the assignment operator private:

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

but don't provide an implementation - you will get a compile or link-time error if you try to perform an assignment to A.

I prefer to use a macro to do this. This also prevents copying, by making the copy constructor private too:

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

I can then say things like:

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

which is easy to read and easy to search for.

---

declare the assignment operator as private.

---

Yes - define a private assignment operator (operator=) or derive from the handy boost::noncopyable class.

---

As of C++11, my understanding is 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

---

Use const.

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

---

I use to derive my noncopyable classes from a common noncopyable class. If 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.

---

The other answers here are all correct. However, it is important to note that you are only prohibiting the specific code you mentioned. Someone can still come along and make a duplicate of your class by using memcpy or other strategies.