Explain why memberwise assignment can cause problems with a class that contains a pointer member.

Memberwise assignment is the default assignment operation provided by the compiler for a class if no custom assignment operator is defined by the programmer. In case of a simple class with only basic datatypes as members, memberwise assignment works fine. It means that each member of the source object is copied to the corresponding member of the target object.

When a class contains a pointer member, memberwise assignment becomes problematic. This is because the default assignment operation will only copy the value of the pointer (i.e., the memory address) but not the actual memory block to which the pointer points. As a result, both the source and target objects will point to the same memory block, leading to possible issues like double deletion of memory, unintentional mutation of the shared memory block, and incorrect behavior.

Consider a class `StringWrapper` containing a `char` pointer: class StringWrapper { public: StringWrapper(const char* str) { size = strlen(str); data = new char[size + 1]; strcpy(data, str); } ~StringWrapper() { delete[] data; } private: char* data; size_t size; }; Now let's create two objects and perform memberwise assignment: StringWrapper str1("Hello"); StringWrapper str2("World"); str2 = str1; After the assignment operation, the memberwise assignment only copies the pointer, and both `str1` and `str2.data` contain the same memory address. This leads to a problem when the objects are destructed since the same memory block will be deleted twice (once by the destructor of `str1` and once by the destructor of `str2`), leading to a crash or undefined behavior in the program.

To avoid problems with memberwise assignment in a class containing a pointer member, we need to define a custom copy assignment operator for the class. In this custom assignment operator, we must ensure that the actual memory block is copied, and not just the memory address. This makes sure that each object has its own separate memory block, avoiding issues like double deletion or unintentional mutation.