assignment operator not always called

Question

I have a template class with two functions, extracts shown below;

template<class TYPE, class ARG_TYPE>
int MyClassT<TYPE, ARG_TYPE>::Add(ARG_TYPE newElement)
{ 
    TYPE Element = newElement; <--- TYPE operator= not called, shallow copy
'
'
}

and

template<class TYPE, class ARG_TYPE>
void MyClassT<TYPE, ARG_TYPE>::SetAt(int nIndex, ARG_TYPE newElement)
{ 
,
,
m_pData[nIndex] = newElement;  <--- TYPE operator= is called, deep copy

'
'
}

Why does the first case result in a shallow copy, yet the second case in a deep copy? I'm assuming a copy constructor is being substituted in the first case, but don't see why.

Answer 1

TYPE Element = newElement; <--- TYPE operator= not called, shallow copy

This should call copy-constructor, not operator=(), as this is not assignment statement. This is initialization.

• Initialization invokes copy-constructor. In initialization, a new object is constructed.
• Assignment invokes operator=(). In assignment, old object is updated with a given value.

So, have you defined a copy-constructor for TYPE?

Answer 2

I'm assuming a copy constructor is being substituted in the first case, but don't see why.

That is exactly what is happening. The C++ standard mandates this behaviour. You should make your copy constructor do the same thing as your assignment operator.