Multiple Choice Quiz

1. Consider the function template:
template <typename T, typename U>
void pair(T a, U b) { /* ... */ }
When calling pair(5, 3.14), what types are deduced for T and U respectively?

(A) Both would be promoted to double

(B) int and double

(C) double and int

(D) Both would be demoted to int

(E) It depends on how a and b are used in the function body.

2. Given the following code:
  template <typename T>
  std::string Version(T in) { return "Generic"; }
  template <>
  std::string Version(std::string in) { return "String"; }
What would happen if you ran Version("test")?

(A) The type of "test" is natively std::string, so "String" would be returned.

(B) The type of "test" is natively const char *, which can be used in either Version, so the call is ambiguous.

(C) The type of "test" is natively const char *, so "Generic" would be returned.

(D) The type std::string has a constructor to take the type of "test", giving it priority, so "String" is returned.

3. Which of the following statements about reference collapsing is TRUE?

(A) It can cause an rvalue argument (&&) to be converted into an lvalue reference (&)

(B) It always results in an rvalue reference if either the argument or the parameter is an rvalue reference.

(C) It is a feature that was deprecated in C++14 and should no longer be used.

(D) It only applies when arguments are rvalue references.

4. How does the keyword mutable modify a lambda?

(A) It allows the lambda to modify captured variables

(B) It allows the lambda to be reassigned to a different function

(C) It allows the captured value to be changed outside of the lambda

(D) It makes all captures capture-by-reference

(E) It means the types of any parameters to the lambda will have to be deduced

5. Is there a problem with the following code? Why or why not?
auto iter = std::ranges::min_element(std::vector<int>{3, 1 , 2});
std::cout << *iter << std::endl;

(A) Yes, it will throw an exception inside of the first statement when you try to get an iterator of an r-value

(B) Yes, it will crash at the end of the first statement when the temporary vector ceases to exist

(C) Yes, it will trigger undefined behavior when you dereference a dangling iterator

(D) Yes, it will trip an assertion when you try to print the contents of the iterator

(E) No, the ranges library fixes any of the above issues

6. Template parameters are processed in two phases. Which of the following happens in the SECOND phase?

(A) All functionality that is depending on template parameters is double-checked.

(B) Basic syntax errors are identified.

(C) All undefined behavior is analyzed and errors are issued.

(D) Static assertions that don't depend on template parameters are checked.

7. Given the following function template:
  template <typename T>
  bool CompareToZero(T in) {
    return in == static_cast<T>(0);
  }
Which function call will NOT cause a compilation error?

(A) CompareToZero<std::string>("12");

(B) CompareToZero('c');

(C) CompareToZero(0, 0);

(D) CompareToZero(std::vector<int>{0});

8. Which of that following is a potential downside of excessive use of templates, even when fully adhering to the C++ standard?

(A) It is likely to cause memory leaks.

(B) It can lead to reduced accuracy in floating-point calculations.

(C) It can lead to larger binary sizes due to code bloat.

(D) It is likely to reduce the final execution speed of the program.

(E) It is likely to interfere with any pre-processor macros that were set up.

9. What is a template specialization?

(A) Any template that will work with only a subset of possible template parameters.

(B) Any template that is divided into multiple pieces in its definition.

(C) Any template that is focused to solve a small, well-defined problem.

(D) Any template recipe with the specific template parameters filled in.

10. When does capturing occur in a lambda?

(A) It depends on whether the variables are being captured by reference or by value

(B) It is up to the compiler to decide

(C) When the variable being captured was first created

(D) When the lambda is called

(E) When the lambda is created