Rationale

Good C++ programmers are familiar with structures, whether they use them regularly or not. There are variations in how they are defined, and a solid grasp with respect to these subtleties will help to ensure efficiency during development.

Correct answer:

1. The first definition defines the type, only. It does not instantiate the structure. The second does not create a type at all. Rather, it instantiates “apple” for use in the current scope.
2. The sample code requires an “apple” type, which means that the first definition is the correct one.

Red flags:

Not knowing the difference between these two snippets of code is not critical, as the issue is trivial and will be caught during compile time. However, it tends to suggest that the candidate does not have a great deal of experience with the language.

4 – Define the following terms that are commonly used in the language:

1. Friend class
2. Overloaded operator
3. Static variable
4. Protected variable

Rationale

C++ shares terminology with other languages, so it is important that interview questions probe the candidate’s knowledge with respect to areas for which there may be ambiguities or differences. A similar situation occurs when database developers migrate to other platforms. Both Oracle and MySQL support the structured query language (SQL), but there are dissimilarities that may cause delays in transitioning. This question will, at a minimum, indicate the prospect’s familiarity with the terminology.

Correct answer:

1. A friend class is one that is allowed access to the private and protected members of any class that has declared it a friend. The property is not inherited (subclasses of friends do not become friends automatically), and not transitive (friends of friends are not friends).

   Having an understanding of friend classes is valuable for both developing and debugging, and it would be a red flag if the candidate has never heard of it in the context of OO design. That said, the syntax and usage is straightforward, and can easily be referenced as long as the programmer knows that the technique exists.

2. Overloaded operators are those for which the default functionality has been altered. This functionality allows for the customization of programming language operators such as the plug sign (+).

   A trivial example is the use of a plus sign in string concatenation:
   int: 1 + 1 = 2
   string: “Amazon” + “ programming interview” = “Amazon programming interview”

   Certainly, any C++ programmer will be well familiar with overloaded operators. The approach is commonly used in custom storage classes for accessing and modifying data. The syntax for overloading a specific operator for a class is straightforward, so a demonstration of coding one without using a reference is not important. However, knowing that “+” can be used instead of writing an ugly “plus(…)” function is essential.

3. Static variables are stored in static memory, sometimes referred to as the heap, rather than on the stack. It is important to know that these variables are only initialized once, and the scope persists throughout the entire execution.

   A static variable inside a function will keep track of its value after the function ends, and remains unchanged with subsequent calls to the same function. It is similar to a global variable, but with the accessibility limited to the function.

   All C++ programmers should know what the “static” keyword means, and how to declare this storage class. Static variables are not used in every application, but having never heard of them should be considered a red flag.   

4. When a variable or member function is defined as protected inside its class, it implies a type of restricted access that is similar to private. The difference is that it is accessible by its subclasses, or derived classes.

   The keyword is quite common, and C++ programmers should be well aware of it. In very simply class hierarchies with no derived classes, clearly the functionality is not required. At the same time, it is an important specifier to consider when designing a class hierarchy.

5 – In an object oriented class hierarchy, what is multiple inheritance? In what circumstance will the Diamond problem arise?

Rationale

This question tests the candidate’s depth of knowledge with respect to the object oriented principles that are commonly used in C++. While the question is not specifically about the language, this programming interview covers multiple perspectives. As such, evaluating the familiarity with the paradigm is valuable.  

Correct answer:

Multiple inheritance is not supported by all OOP languages. It is, however, supported in C++. It describes a situation where an object or class inherits features, such as member functions or variables, from more than one parent class. Compare this to single inheritance, where an object or class is restricted to inheriting from a single parent.

While this functionality is powerful, it can lead to the Diamond problem.

Consider the top-level class: “A”, which has two sub-classes “B1” and “B2”. Each of the child classes singly inherits from the parent class, “A”. It is when a third level, “C”, is added that the problem may arise. It can occur only if sub-class “C” inherits from both “B1” and “B2”.

Furthermore, it will only occur if there is a method defined in “A” that is overridden in both “B1” and “B2”, but is not overridden in “C”. If this method is invoked by “C”, then there is ambiguity concerning which method to use.

It is not important to know how this problem is solved in C++. Rather, one should recognize that the problem exists and should be considered when designing a class hierarchy.

Red flags:

If the candidate does not know what multiple inheritance is, then it suggests a lack of objected oriented design experience. While not critical for all applications, OOP is an integral part of C++.

6 – Recursion is a common technique used in C++ programming. What are the advantages and disadvantages of using recursion? Provide an example for which recursion is well suited.

Rationale

Recursion is an oft-used technique by programmers that helps to simplify coding. Whether programming from a clean slate, adding functionality, or maintaining an existing code base, a developer is virtually guaranteed to see or use recursion. There are specific things to consider when developing or debugging a recursive function, so familiarity with the technique is important.

Correct answer:

The simplest definition is that a recursive function is one that calls itself.

The main advantage is that it leads to simpler, more elegant code. This in turn is easier to develop and, at least theoretically, leads to fewer errors.

The main disadvantage is that recursion is often slower in practice compared to its iterative counterpart. This performance hit is not attributable to complexity, but rather, a recursive function uses more memory. Each recursive function call reserves additional space on the stack, causing it to grow. If the recursion is too “deep”, meaning that it goes for too long before returning, it can result in a “stack overflow” error.

Examples of well suited situations

Tree structures, such as a binary search tree, are very well suited to recursion. Similarly, when there is a variable number (or a very large number) of nested loops, the recursive version will be much more elegant. Sorting algorithms such as Merge sort, Quick sort, and Bubble sort are all easier to implement recursively.

Red flags:

Recursion is a technique that is covered early in a programmer’s education. The candidate should certainly be able to describe it, and also know that it consumes more memory (stack space) than the iterative version of the same algorithm. Also, knowing that it is well suited for tree structures is trivial.

Bonus

The way to avoid excess memory consumption and the stack overflow error is to use tail-recursion (also known as tail-recursion optimization), as long as it is supported by the compiler. Knowing that this exists, without describing how it works or how to code for it, should still be considered a plus. Obviously, an in-depth knowledge of tail-recursion subsumes the purpose of the original question.

7 – Smart pointers were introduced in C++11 to assist with memory management and prevent memory leaks. The following questions address the allocation of memory for data used within the program, irrespective of type.

1. Briefly describe the difference between:

   unique_ptr<>
   shared_ptr<>
   weak_ptr<>

2. In the following code, what is the best choice of smart pointer (replace ??? with the correct choice), and why? What happens to the memory reserved for “p” when the function exits?

void printModifiedArray(int *nums, int length)
{
	// Allocate memory for a new array used only in this function
	std::???_ptr p(new int[length]);

	// Copy the int data with the proper size of data type
	std::memcpy(p.get(), nums, sizeof(int)*length); 

	// Iterate through the elements in the array
	for (int a = 0; a < length; a++)
	{
		// Call the destructive shiftInt() function
		shiftInt(p[a]);
		// Output the modified numbers from the array
		std::cout << p[a] << " ";
	}

	// Conclude with a newline escape sequence
	std::cout << endl;
}

Rationale

Memory allocation and pointer errors are traditionally some of the most difficult problems in C++ to detect and repair. A large number of independently developed memory management libraries assisted developers for many years. With the release of the C++11 standard, the introduction of Smart pointers went a long way towards fixing these long-standing and difficult problems. Developers at every level should be proficient in their use.

Correct answer:

1. A unique pointer (unique_ptr) is a smart pointer that will automatically deallocate the reserved memory as soon as it is out of scope. Only one unique_ptr can point to a resource, so it is illegal (at compile time) to make a copy of a unique_ptr.
2. A shared pointer (shared_ptr) is also a smart pointer that automatically deallocates the reserved memory once it is out of scope. However, a single resource can be simultaneously referenced by many shared pointers. An internal reference counter is used to keep track of the shared_ptr count for any given resource. If there are no references then the memory is freed. This is susceptible to the problem of circular dependency in cases where two or more shared pointers reference each other.
3. A weak pointer (weak_ptr) indeed references the memory, but is not able to use it before being converted into a shared pointer. This is done by using the lock() member function.  Using weak pointers is a common way to deal with the problem of circular dependencies. There is no reference count, but as such, the resource is first verified as soon as lock() is called. If the memory is still available then it is usable as a shared pointer. However, had it been deallocated previously then the lock() would fail.
   
   

In the code snippet, the best choice is the unique_ptr. Certainly, a shared_ptr will work, but having to keep track of references when the function does not call for a shared resource is inefficient. C++ developers have been known to use exclusively shared pointers, although this is frowned upon due to the accompanying performance degradation. A suggestion to use the weak_ptr would indicate that the candidate has no experience with smart pointers.

When the function returns, if the memory reserved for p is held by a unique_ptr or a shared_ptr then it will be automatically deallocated.

Red flags:

If the candidate has no knowledge of smart pointers or how to use them, it indicates a lack of experience in an important part of the programming language. Smart pointers were introduced in C++11, and although a veteran C/C++ developer can get by without them, the benefit that comes with their use is not something that should be ignored. 

8 – The explicit type conversion of a variable, also know as casting, is an operation that is used often in C++. There are several functions, each with its own properties.

1. Under what circumstances should dynamic_cast be used?
2. Why is reinterpret_cast considered to be dangerous?
3. In the following code, what type of cast, if any, would you choose to make the password variable writable?