Copy Constructor

Alternate answer (posted after the OP re-tagged his post with C++)

Okay, with native code it is as you understand it. The default copy ctor will just copy the pointer members over so that the object's copy will have member pointers that are pointing to the same objects as the original's members are.

It's purely a design consideration whether this is desirable or not. Some designs may warrant a shallow copy, others may absolutely require a deep copy. When you need to have full control of how this copy works, you need to add your own copy constructors.

See this sample chapter from my book:

http://www.manning.com/sivakumar/sample-ch01_sivakumar.pdf[^]

Scroll down to section 1.5.3 on Copy constructors.

I never use the default copy constructor and often declare it private and do not define it. In some classes, I never want to use a copy constructor. Using the default copy constructor makes it easier to make programming bugs inadvertently and makes shallow instead of deep copies.

Say you have the class

class MyString {
	public:
		MyString() {
			m_szTheString = NULL;
		}
		MyString(const char *szString) {
			size_t nLen = strlen(szString) + 1;
			m_szTheString = new char[nLen];
			memcpy(m_szTheString, szString, nLen);
		}
		~MyString() {
			if (m_szTheString != NULL) {
				delete []m_szTheString;
			}
		}
	//Functions that are irrelevant to this sample
	//...
	private:
		char *m_szTheString;
};

This is using the default copy constructor.
if we look at this class in memory, it takes 4 (or 8 on 64 bit) bytes of memory, to store the pointer to the string held in m_szTheString.

Then the default copy constructor does what is called a "shallow copy", that is copy the memory from 1 instance to the other. Think of it like this:

MyString strA("hello");
MyString strB(strA); //copies the 4 bytes for the pointer

is (conceptually) equivelent to

MyString strA("hello");
MyString strB();
memcpy(&strB, &strA, sizeof(MyString)); //copies the 4 bytes for the pointer

This means that both classes now have a pointer to the same memory address (the actual string), so if 1 of the objects changes the string, then it changes in the other 1 too.

By using your own copy constructor you can make a copy of the memory referanced too.

MyString(const MyString &strOther) {
	//The default would be equivelent to: m_szTheString = strOther.m_szTheString;
	size_t nLen = strlen(strOther.m_szTheString) + 1;
	m_szTheString = new char[nLen];
	memcpy(m_szTheString, szString, nLen);
}