Multiple Choice Quiz

1. In the context of C++ metaprogramming, how would a metafunction typically be implemented?

(A) As a lambda function wrapper around an existing function

(B) As a macro

(C) As a class/struct that takes arguments via templates and stores info as members

(D) As a function that takes another function as an argument

(E) As a typical function that can return different values depending on the context in which it was called

2. Why would you return std::optional from a function?

(A) To avoid exceptions when a function fails to compute a valid result, offering a way to check for a result without the overhead of exception handling

(B) To indicate that the function may or may not exist

(C) To improve the performance of the function by avoiding value copying

(D) To enable automatic memory management and prevent memory leaks

(E) To allow the function to return multiple values of different types at the same time

3. There are several things to make sure you understand when benchmarking, which of the following is NOT a reasonable expectation?

(A) Ensuring that you understand which portions of your code you are actually benchmarking

(B) Ensuring you understand how your benchmarking code interacts with the compiler's optimizations

(C) Ensuring that only benchmark your code via short, almost trivial use cases to save time

(D) Ensuring you know which compiler flags you are using and how they will effect benchmarking

(E) Ensuring your benchmarking code does not needlessly inflate your timing results

4. When an argument is passed by value into a function parameter, which of the following statements is true?

(A) The function can modify the original value of the argument that was passed in

(B) It is almost always more memory efficient than passing by reference

(C) The function receives a copy of the argument

(D) It is almost always less memory efficient than passing by reference

(E) The original object's destructor is called when the function parameter goes out of scope

5. Which standard C++ library provides time-based tools that can be used for benchmarking?

(A) chrono

(B) duration

(C) metrics

(D) time

(E) snapshot

6. What does the typename keyword do in the following snippet?
template <typename T>
using my_type_t = typename MyType<T>::type;

(A) Extracts and returns the type of the variable MyType<T>::type

(B) It is ignored by the compiler, but it tells other users that my_type_t is a type

(C) Removes const and volatile qualifiers from MyType<T>::type

(D) Tells the compiler that MyType<T>::type will eventually resolve to a type

(E) Converts a string, like int, into an actual C++ type

7. What is the standard way to return a value from a metafunction?

(A) By overriding GetValue() from the standard

(B) By a normal return call, return value;

(C) By returning the value from the constructor

(D) By deriving from that value

(E) By storing it as a static constexpr member of the class

8. When should you avoid marking a function as constexpr?

(A) When the function is called from many different places in your code

(B) When the function has a recursive call to itself

(C) When the function is overly long

(D) When it needs to interact with a library that does not use constexpr

(E) When the function will sometimes need to be called at run time

9. If you have a function template with two types T1 and T2 and want to change what code is run based on whether they are the same or different, what condition would you put inside your if constexpr?

(A) std::is_same<T1 == T2>()

(B) std::is_same<typename T1, typename T2>

(C) std::is_same(T1, T2)

(D) std::is_same<T1,T2>::value

(E) std::is_same(T1)(T2)

10. If you want to use value semantics on objects of a given class, which of the following is most important to implement?

(A) An operator<< for printing

(B) A set of data accessors

(C) A virtual destructor

(D) A copy constructor

(E) A friend class