Safe to use the compiler generated assignment operator?

Question

I'm using the CPoint class from MFC. There is no explicitly defined assignment operator or copy constructor (AFAIK). Yet, this works:

CPoint p1(1, 2), p2;
p2 = p1; // p2 now is equal to p1

I'm assuming this is working automagically because of a compiler generated assignment operator. Correct?

If so, can I be confident that this isn't doing anything unexpected? In this case CPoint is so simple I think all is well, but in general this is something that worries me a bit. Is it better form to do:

p2.SetPoint(p1.x, p2.x);

-cr

Answer 1

If a class is "simple", then the compiler-generated assignment operator will work (memberwise copy). If there are some members that would require more advanced logic (let's say the object maintains an internal pointer to what it expects is a private buffer), then the compiler-generated assignment operator will have issues. CPoint just stores an x and y coordinate of a point, so you should not run into issues.

Answer 2

I don't know MFC, but I can guess that (alternatively):

• CPoint has a defined assignment operator (so not compiler-generated), or
• Compiler-generated assignment operator works when members are stack-allocated, so it does memberwise copy.

Answer 3

This is safe - if an assignment operator wasn't meant to be supplied then the MFC designers could of made sure it wasn't available (by making it private for example).

IIRC the compiler will perform a member-by-member copy, so for a class containing POD like this, you won't have a problem. It can get messy if you have a class that allocates memory and neglects to override operator= and perform a deep-copy.

FWIW I asked a question about what the compiler can and cannot do a while back:

http://stackoverflow.com/questions/217911/why-dont-c-compilers-define-operator-and-operator

Some of the answers make for interesting reading.

Answer 4

The builtin copy assignment operator just copies each member in turn using their copy assignment operators. I assume that it's safe for CPoint without looking at its documentation (reason: If it wasn't they would provide an own implementation, of course). That point class should just have two members (x and y) and those are just floats (or int depending for what it's used).

One says it's a "shallow copy" since only the values of the members are copied. If you have pointer members, the pointer values are copied, instead of the objects where the pointers point to.

Answer 5

Look up default copy constructor:

http://www.fredosaurus.com/notes-cpp/oop-condestructors/copyconstructors.html

This isn't a special thing about CPoint.

Answer 6

For a simple data object like CPoint (which you can see from the MFC source included with your Visual Studio installation is just a Win32 POINT structure with a few convenience functions tacked on), there is nothing wrong with using the compiler-generated assignment operator.

But as already mentioned, the default assignment operator is a shallow copy and will get you into trouble if the structure contains pointers (or contains structures that contain pointers without defining an assignment operator). Since CPoint doesn't fit that description, it's safe.

Answer 7

Yes. If you define no operator= method on a class, the compiler generates one for you that simply does a bitwise copy of the fields in the class. As I recall, CPoint is merely {int x; int y}, and so bitwise copy is fine.