C++ Interview Questions

Shallow copying is faster, but it's "lazy" in how it handles pointers and references. Instead of making a fresh copy of the actual data the pointer points to, it just copies over the pointer value. So, both the original and the copy will have pointers that reference the same underlying data. (Ditto for references.)

Deep copying actually clones the underlying data; it's not shared between the original and the copy.

Let's get specific. Here's a class representing a bus:

Pay close attention to our routeList_ variable. We've made it a pointer so that it can be updated remotely (in case there's a detour). We've also included methods to manipulate the list of stops and print out the bus information.

What do you think happens when we run this code?

Here's the output:

Oops. Looks like the local and express bus were both sharing the same route list. Like this:

Okay, so when we created the express bus (Bus express = local), we made a shallow copy, where both objects ended up with a pointer to the same route list.

We want the express to be a deep copy of the local bus, so that they each have their own route list.

How can we get deep copies?

Well, what happens when we run this line of code:

In C++, there are two functions that copy the values from one object to another: copy constructors and copy assignment operators.

The copy constructor gets called whenever we are constructing a new object from an existing one. So, this declaration uses copy constructors:

And, this code block also uses the copy constructor (even though there's an equals sign):

The copy assignment operator gets called when we're updating an existing object:

Let's look back at the line where we created our express bus. Would it call the copy constructor or the copy assignment operator?

Since we're creating the express bus, we'll use the copy constructor here.

Wait a second though. We didn't ever define a copy constructor! Where's the function that's getting called?

When writing a class, defining a copy constructor and a copy assignment operator is optional. If you don't specify one, then the C++ compiler will generate it for you, filling in a method that makes shallow copies.

If we want deep copies, we can get them be defining a copy constructor and assignment operator for our Bus class. Here's what our copy constructor could look like:

The line of code: routeList_(new vector<string>(*src.routeList_)) creates new space so that the new Bus object can have its own route list.

Now, when we create our express bus, it'll call the copy constructor we just wrote:

Under the hood, our buses will look like this:

That covers the copy constructor. What about the copy assignment operator?

We probably want to define that too. Otherwise, we'll get deep copies whenever we use the copy constructor but shallow copies whenever we use the copy assignment operator. That sounds like a surefire way to get some bugs.

So, let's write out a copy assignment operator that will make deep copies. It'll look a lot like the copy constructor, except we'll want to clean up the existing object before we start assigning new values. Like this:

One last thing to note: copy constructors don't have to create deep copies. Sometimes, we want a separate copy of some of the class members and a shared reference for others.

For instance, if we add information about the bus supervisor, we'll probably want the same supervisor for all buses. So, we can let them share a reference to the supervisor name, while creating a separate copy of the route list:

The diamond problem refers to an issue when a base class is inherited by two subclasses, and both subclasses are inherited by a fourth class. When this happens, we need to give the compiler a bit of guidance about the exact structure of inheritance we want.

Let’s use the example of lions, tigers, and ... ligers:

We'll start with a base class, Mammal, with the method eat:

Lion and Tiger both inherit from Mammal:

Finally, Liger inherits from both Lion and Tiger:

This is the inheritance structure we're going for. (See how it looks like a diamond!)

Satisfied with our structure so far, we decide to write some code using the Liger class:

But, when we compile it, we get this error message:

What's happening here?

The compiler is complaining that the Liger class has two versions of the eat method—one from the Tiger class (which inherited it from the Mammal class) and one from the Lion class (which also inherited it from the Mammal class). So, the compiler sees two different eat methods, and it doesn't know which version it should use for Ligers.

This happens because C++ doesn't recognize that the Lion and Tiger classes are inheriting from the same Mammal class. What it sees instead is something like this:

We can ensure that the compiler inherits the same Mammal class into the Lion and Tiger classes with the virtual keyword, like this:

When a base class is virtually inherited, the C++ compiler makes sure that this class is created only once. That means that all subclasses, like Lion and Tiger, will lead back to the same Mammal base class, giving us the diamond structure we've wanted all along.

Note that we have to put the virtual keyword in the definition of both Tiger and Lion. If we don't then we'll get the incorrect structure we had before.

The virtual keyword can also be used with class methods. When a class method is declared virtual, it can be overridden by inheriting classes.

Going back to our example with animals, we might want to let different mammals define their own eat method. Since we'll be overriding the eat method in inheriting classes, we need to declare it as virtual, like this:

When developing classes, most public or protected methods will be declared virtual so that inheriting classes can override them as needed. In fact, the only method that can't be declared virtual is the class constructor. (Clearly, we don't want others to override that!)