Multiple Choice Quiz

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

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

(B) You should never use default values for variables

(C) In the body of each constructor

(D) In the initializer list for every constructor definition

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

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

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

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

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

(E) Utilize global variables to store commonly used parameters

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

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

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

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

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

(D) You must use the -O3 optimization flag

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

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

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

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

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

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

5. When should you use the override keyword?

(A) When you want to ensure that a derived function pairs with a virtual function in the base class

(B) Whenever you have multiple functions with the same name and want to ensure that they can each be called

(C) When you want ensure consistency in a function's return value and need to override it into a specified range

(D) When you want to replace an old definition of a function with a new one

6. We should always mark a member function as const if it doesn't change the objects value. Which of the following is NOT a reason for this?

(A) So that the compiler creates an error if we accidentally change the object when we are not expecting to

(B) So that the member function can be called on const versions of the associated object

(C) It will allow the function to be run in derived versions of this class.

(D) So that the compiler might be able to optimize the code more effectively

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

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

(B) 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

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

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

(E) 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

8. What is the difference between default initialization of a variable and value initialization?

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

(B) Default initialization leaves user-defined classes uninitialized, while value initialization runs their constructor

(C) Default initialization leaves built-in types uninitialized, while value initialization initializes them to zero

(D) Default initialization always initializes the bytes of any variable to all zeros, while value initialization is customizable

9. What is the advantage of using std::make_unique or std::make_shared over constructing your unique/shared pointers directly?

(A) It simplifies the allocation process, passing arguments straight through to the constructor

(B) It sets the output type to be a smart pointer so that deletion will be handled properly

(C) It provides a performance improvement

(D) It makes it easier to swap the underlying pointer

10. Andrei Alexandrescu's short string optimization is often given as an example of really clever problem solving.
What did he gain when he swapped string size for _remaining_ string size?

(A) Remaining size is guaranteed to never be zero

(B) For a full string, the size was also used as the null terminator

(C) It required fewer bits to store the remaining size as compared to full size

(D) This swap ensured that the strings would always be able to fit into cache

(E) All of the above