Automatics (Copy Constructors & Assignment Operator)

Question 1

What is an automatic function and what are the four that every class has?

Answer 1

An automatic function is automatically created by the compiler if the user doesn’t create one for the class.

The four automatic functions every class has are:

Constructor
Destructor
Copy Constructor
Assignment Operator =

Question 2

What is inside the automatic default versions of the constructor and destructor?

Answer 2

Nothing – they are empty.

Question 3

If a class doesn’t have a default constructor (but does have a parameterized constructor) will a default constructor be automatically created?

Answer 3

No. Not all classes have a default constructor, nor are they required.

Question 4

What kind of copy do default constructors and copy constructors make?

Answer 4

A shallow copy.

Question 5

What is a shallow copy?

Answer 5

Copy of all members and data, but any pointers and references are copied verbatim.
They end up pointing to same attached data – that’s not good! They need to be updated to new memory locations or errors are highly likely.

Question 6

What is a deep copy?

Answer 6

Copy all members and data, but also makes copies of attached data as well (which is external from the physical “object”, such as dynamic memory.)

A deep copy has to be manually written to handle these tasks.

Question 7

What is a copy constructor?

Answer 7

A constructor invoked automatically when a new copy of an object is created.

Question 8

When are copies of an object created with the copy constructor?

Answer 8

Copies are made when:

1. An object is declared and initialized to another object’s value in the same statement.

// Calls copy constructor
MyObject o2 = o1;
// Different syntax, but identical functionality
MyObject o2(o1);

2. An object is passed into (or returned from) a function by VALUE

Question 9

Will this call the copy constructor?

f1 = f2;

Answer 9

No, it will call the assignment operator.

Question 10

Explain how to declare a copy constructor and why each component is necessary.

Answer 10

The copy constructor is declared in the format of:

ClassName(const Typename& var);

For example, if the class was MyObject:

MyObject(const MyObject& original);

The ClassName of MyObject is how we know which class this is a constructor of.

The object to be copied MUST BE passed by CONST REFERENCE because it should not be modified – only copied.
I used the variable name “original” to make it very clear when the original’s data is being referenced within the constructor’s definition, e.g. value = value.original;

Question 11

When is an assignment operator overload invoked? Does it need to be a member function? What is the syntax of the overload’s declaration? Explain each part off that syntax.

Answer 11

The assignment operator overload is invoked any time an assignment statement is made, i.e. something is being assigned to an object.

mo1 = mo2;

Yes, it must be a member function.

// Syntax of assignment overload declaration
Typename& operator= (const Typename& var);

Returning the Typename by reference allows cascading with =. Must be passed by const reference to make a copy without the original being changed.

Example:
MyObject& operator= (const MyObject& original);

Question 12

What are common considerations of the assignment operator overload for a class?

Answer 12

1. It should be treated similarly to a Copy Constructor with regards to deep copies.
2. Must return *this by reference, which enables the cascading of the = operator.
3. May need previously attached data to be deleted.
4. May need protection from self-assignment.

Question 13

Describe what the keyword ‘this’ is used for.

Answer 13

‘this’ is a pointer to the calling object and can be used like any other pointer (dereferenced with *, arrow operator ->)

It’s used to represent a name for the calling object when such a thing would be necessary, such as returning the object itself.

Question 14

Write a simple way that you would prevent an object from being assigned to itself.

Answer 14

// Will only run the body of the overload if ‘this’ is not the same address as the original that has been passed in.

if (this != &original)
{
// Further assignment code
}

return *this;

Question 15

Write a simple way to handle de-allocation in the assignment overload.

Answer 15

// Prevent self-assignment
if (this != &original)
{

// Since this is not a brand new object,
// we should delete any information
// currently attached: 

delete [] entryList;

 // Further assignment code }

return *this;