Multiple Choice Quiz

1. According to the core guidelines, what is a good technique to reduce the number of parameters to a function?

(A) Use abstractions to combine inputs, such as a Point class rather than separate x's and y's

(B) Use std::pair to arbitrarily group pairs of neighboring parameters

(C) Utilize global variables to store commonly used parameters

(D) Rely on default argument values for most of the function parameters

(E) Build a class around the function where you can pass in the arguments sequentially

(F) Split the function into multiple smaller functions, each taking a subset of the original parameters

2. Which of the following is NOT a difference between enum and enum class?

(A) enum class allows you to be represented internally as a type other than int, but regular enum is always an int under the hood

(B) enum allows you to specify the starting value, while enum class always starts with zero.

(C) enum values automatically convert to int, but enum class must be cast to int

(D) enum class values are only available in the provided class enum namespace, but regular enum values are available outside of the enum namespace

3. How do you speed up your compilation using CPU architecture-specific optimizations?

(A) You can specify the architecture with the -march flag, or -march=native to set it up automatically

(B) This is automatic when you use any of the -O optimization flags

(C) You must use the -O3 optimization flag

(D) You can use the -Oarch flag, though you must also include a separate flag for optimization level

(E) Compilation is always specific to a given architecture and cannot be modified

4. Which of the following is NOT an advantage of using std::unique_ptr over std::shared_ptr?

(A) Faster execution

(B) Reference counting of object instances

(C) Lower memory overhead

(D) Simplicity of single ownership

5. Which of the following will not compile?
Assume std::vector<int> vec = GetVector();

(A) auto iter = std::ranges::min_element(vec);

(B) auto iter = std::min_element(vec.begin(), vec.end());

(C) auto iter = std::min_element(vec);

(D) All of these will compile

(E) None of these will compile

6. Why should I try to avoid casting away const on a variable even when I know that I am not changing its value?

(A) If I am actually not modifying the variable, there is almost always a clearer way of writing the code that keeps it const

(B) A later programmer may modify my code to make a change that will alter the value without realizing that it was originally supposed to be const

(C) Some non-const functions that I use may modify the value it subtle ways without me realizing it

(D) All of the above

7. According to the core guidelines, where should you set the default values for member variables in a class?

(A) In the body of each constructor

(B) You should never use default values for variables

(C) In the initializer list for every constructor definition

(D) In the class definition where you declare each variable

8. If two variables are defined as const int * x and int const * y, what is the difference in their types?

(A) Only the variable x can change which memory position it points to; only y can change the value stored at memory position where it points

(B) Only the variable x can change the value stored at memory position where it points; only y can change which memory position it points to

(C) The variable x can point to both const and non-const integers, while y can only point to const integers

(D) The variable x cannot be set to nullptr, but y can

(E) There is no difference; they are the same

9. What order are a class' member variables initialized in?

(A) The same order as the associated parameters of the constructor

(B) The order in which they are placed in the initializer list of a constructor

(C) The order in which they are declared in the class

(D) This is undefined; they may be initialized in any order

10. Why is it important to use std::unique_ptr in a function that may throw an exception in the middle?

(A) Because it allows for easier debugging

(B) To ensure that the memory is deallocated even if an exception is thrown

(C) Because it makes the code run faster

(D) To handle the exception inside the pointer

(E) The presence of the unique pointer will make the compiler handle any exceptions at compile time