Multiple Choice Quiz

1. According to the core guidelines, should you prefer default arguments in a constructor or multiple versions of the constructor with different numbers of arguments? Why?

(A) You should prefer multiple versions of the constructor so that each version can be clearly commented indicating it purpose

(B) You should prefer default arguments because it's more efficient to have fewer versions of a function

(C) You should prefer default arguments to ensure consistency and help readers expect consistency

(D) You should prefer multiple versions of the constructor so that each version can be optimized to use only those values it needs to

2. Why should a class destructor sometimes be marked virtual?

(A) If the class is a base class, a virtual destructor ensures that the derived destructor is called when delete is called on a base class pointer

(B) If you have any other virtual functions in a class, it is an error not to also make the destructor virtual

(C) You never need to - the compiler will do this automatically if you create any derived class

(D) All derived classes should have their destructor marked virtual to indicate that they are derived classes

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

(A) You should never use default values for variables

(B) In the initializer list for every constructor definition

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

(D) In the body of each constructor

4. Under which of these conditions is it good coding practice to use raw pointers in C++?

(A) Only when you are building custom smart pointers of your own

(B) Any time you are pointing to raw text files

(C) Whenever you write the constructor and destructor at the same time

(D) In a function that uses the pointers, but does not allocate, free, or store them in any way

(E) It is never good coding practice to work with raw pointers in any way

5. What are "structured bindings" in C++?

(A) They allow you to bind specific values to function parameters, resulting in a function that takes fewer arguments

(B) They direct the linking phase of compilation, specifying how various modules should be bound together

(C) They simplify setting multiple variables at once, such as in a for loop of when returning multiple values from a function

(D) They allow you to build a new struct type at run time, without needing to specify it at compile time

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

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

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

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

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

7. How should you handle "magic numbers" in the code, such as 3.141592 for PI?

(A) You should never use magic numbers in code

(B) Set it to a variable so that it can be optimized effectively; e.g.:
constexpr double PI = 3.141592;
double area = PI * r * r;

(C) Have it returned by a function so that its definition is placed in a header file, e.g.:
double PI() { return 3.141592; } // In a header file
double area = PI() * r * r; // Later, where you're using it

(D) Specify the value directly so that it can be optimized effectively; e.g.:
double area = 3.141592 * r * r;

8. Why should you use smart pointers rather than directly calling new and delete yourself?

(A) Because smart pointers are always faster

(B) To simplify debugging

(C) Because new and delete are deprecated

(D) To automatically manage object lifetimes and make memory leaks less likely

9. Which of the following is a valid reason that you should avoid using namespace std; in your code?

(A) You will be polluting your current namespace with every identifier in the standard library

(B) It will drastically limit the identifiers that you are allowed to use in your own code

(C) Bringing in the entire standard library into your code would be considered a copyright violation

(D) The using command is deprecated. You should always use typedef instead.

(E) It will drastically slow compilation times since substantial additional code will need to be compiled

10. According to the core guidelines, what should you do if you have multiple return values?

(A) Always pass the output values by reference as function parameters

(B) Use multiple out-pointers as function arguments for each return value

(C) Return a struct or a tuple that bundles the values together

(D) Use a static class member to temporarily hold the return values

(E) Create separate functions for each return value

(F) Use global variables to store and retrieve the return values

(G) Return a vector or list, even if the values are of different types

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

(A) Lower memory overhead

(B) Reference counting of object instances

(C) Faster execution

(D) Simplicity of single ownership

12. How should you decide whether to use '\n' or std::endl for a newline when you are outputting to a stream?

(A) You should default to '\n' unless it is the final newline for your current output and want to flush the result

(B) You should always use std::endl because it can detect the current context and always behaves correctly

(C) It is only a matter of style; pick the one that you like better and use it consistently

(D) You should always use '\n' because std::endl has been deprecated

(E) You should default to std::endl unless you are generating an ASCII string, which needs a newline character

13. According to the C++ Core Guidelines, what is a good technique to reduce the number of parameters to a function?

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

(B) Utilize global variables to store commonly used parameters

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

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

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

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

14. When should you use the override keyword?

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

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

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

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

15. What can the keyword mutable be used for in C++?

(A) To indicate that a class cannot be made const

(B) To mark a member function as disallowed from being run on a const instance of a class

(C) To specify that a class may be changed unexpectedly (possibly in a different thread).

(D) To mark a parameter to a function that will definitely be modified in that function

(E) To denote a member variable that is still allowed to change in a const member function

(F) To indicate a class where the member variables in the class may vary from one instance to another

16. Two types of smart pointers are commonly used from the C++ standard library, std::unique_ptr and std::shared_ptr. How should you decide which one to use?

(A) Use std::shared_ptr when you want the object to be modifiable from multiple functions, and std::unique_ptr when modifications should be restricted to one module.

(B) Use std::unique_ptr when you are working with smaller objects, but use and std::shared_ptr when the object is large or expensive to copy.

(C) Use std::shared_ptr for polymorphic objects since they require dynamic management, and use std::unique_ptr only for non-polymorphic types.

(D) Use std::unique_ptr by default because it is more efficient and less likely to leak memory; only use std::shared_ptr when you need to share ownership across multiple parts of your program.

(E) Use std::unique_ptr if you know you are going to have only one instance of a class, but used std::shared_ptr if you are likely to have many instances.

17. While function arguments may be processed in any order, the same is not true for initialization lists. Consider the following C++ structure:
  struct MyClass {
    int a;
    int b;
    int c;
    MyClass(int x) : c(x++), b(x++), a(x++) { }
  };
If you create a variable with MyClass var(7), what will be the values of a, b, and c?

(A) a=9, b=8, and c=7

(B) a=9, b=9, and c=9

(C) a=7, b=8, and c=9

(D) a=7, b=7, and c=7

(E) The code above will not compile because the initialization list is in a different order from the declarations of the member variables.

18. Which of the following is true about the C++ Core Guidelines as a whole?

(A) They are specifications that compiler writers must follow when implementing the C++ standard

(B) They are a more intuitive version of the C++ standard

(C) They are purely stylistic rules that make arbitrary decisions based solely around consistent appearance in code

(D) They are requirements that extend the C++ standard and must be followed in all programs

(E) They are suggestions for improving your code by making it more consistent and easier to debug

19. Which of the following is NOT one of the C++ Core Guidelines? Hint: all of the others were mentioned in the core guidelines video that you watched.

(A) Prefer setting default values for member variables in the class definition where you declare each variable

(B) Consolidate logically related inputs into a single user-defined type (e.g., a class or struct) that encapsulates the necessary data

(C) If you need to return multiple values, use a struct or a tuple that bundles the values together

(D) Prefer default arguments in a constructor rather than multiple versions of the constructor (to ensure consistency)

(E) Introduce global variables to hold frequently used values, thus eliminating the need to pass them as parameters

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

(A) It's the only way to ensure that the pointer will have new memory allocated for it

(B) It's just a convenience that simplifies the allocation process, passing arguments through to the constructor

(C) It provides a performance improvement

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

21. 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 handle the exception inside the pointer

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

(D) Because it makes the code run faster

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

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

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

(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) If I am actually not modifying the variable, there is almost always a clearer way of writing the code that keeps it const

(D) All of the above

23. Which of the following is good advice for deciding when to use a range-based for loop like:
for (auto & x : data) { ... }
versus an indexed-based for loop:
for (size_t i=0; i < data.size(); ++i) { ... }
when iterating over a vector?

(A) Default to an index-based for loop unless you are changing elements in the vector as you go

(B) Never use range-based for loops if you can avoid them since index-based loops are more efficient

(C) Never use index-based for loops if you can avoid them since range-based loops are more efficient

(D) Make sure to use an indexed-based for loop if you are using pushing new elements on the back of the loop as you go

(E) If both work for your needs, there is no reason to choose one over the other

24. Which of the following is a good reason to use std::unique_ptr instead of a raw pointer?

(A) We want to clarify where in the code this pointer is owned

(B) We want to store the pointer in a std::vector

(C) We want multiple pointers to share ownership of the object

(D) We want to be able to swap the underlying pointer easily

(E) We never plan to dereference the pointer

25. Sometimes arguments in a function call may have side-effects, so it's important to understand their order of evaluation. What will the following code output?
  int Compute(int a, int b, int c) { return a + 3*b + 10*c; }
  int main() {
    int i = 0;
    std::cout << Compute(i++, i++, i++) << std::endl;
  }

(A) 12 // i.e., Compute(2,0,1)

(B) 23 // i.e., Compute(0,1,2)

(C) 5 // i.e., Compute(2,1,0)

(D) 21 // i.e., Compute(1,0,2)

(E) Any of the above are legal; the results depend on the compiler

26. If you want to compile a C++ program without any optimizations turned on, how can you do this with clang or gcc?

(A) You must put the compiler in debug mode with the -g command-line option

(B) You must use the --no-debug command-line option

(C) You must explicitly use the flag -Onone

(D) You must use the -DNDEBUG command-line option

(E) You can simply compile without setting any optimization flags

27. Which of the following C++ utilities allows you to express an intention to have a value that might or might not be present?

(A) std::none

(B) std::maybe

(C) std::any

(D) std::nullable

(E) std::optional