Thread: Deep and Shallow Copying

Hi

i need to have a understanding of Connecting 2 strings using binary “+” operator in plain English. i don’t need to be able to write any code just need to understand the principle.

I believe i have a basic understanding on how deep copying works

· Measure lastname
· Measure firstname
· Create a block of memory for firstname + lastname + 1 for string marker
· Copy firstname into new block
· Concatenate lastname into new name block
· Delete firstname (if this is not done a memory leak will occur)
· Return new name

this will be using pointers as its a deep copy. if any of the above is incorrect could you point me in the right direction

also if possible can anyone help me understand how this process above of copying a 2 strings together is different for a shallow copy?

Thanks

Here's an example that shows the concept of Shallow vs. Deep copying:

Code:

class Something
{
private:
   char*  m_SomeData;
   char*  m_ArrayOfStrings[10];

public:
   void ShallowCopy( const Something* pData )
   {
      // Just copy the pointers.
      m_SomeData = pData->m_SomeData;
      m_ArrayOfStrings = pData->m_ArrayOfStrings;
   }

   void DeepCopy( const Something* pData )
   {
      // Copy the data that the pointers are referencing.
      m_SomeData = new char[ strlen( pData->m_SomeData ) ];
      strcpy( m_SomeData, pData->m_SomeData );

      for ( int i = 0; i < 10; ++i )
      {
         m_ArrayOfStrings[ i ] = new char[ strlen( pData->m_ArrayOfStrings[ i ] ) ];
         strcpy( m_ArrayOfStrings[ i ], pData->m_ArrayOfStrings[ i ] );
      }
   }

   ...
};

Shallow copying makes an exact byte by byte copy (including the pointers & references) of the other class.
Deep copying doesn't just copy the pointer values, it allocates new memory and copies the data that is being pointed to, not just the address of the data...