Multiple Choice Quiz

1. Is the following C++ code valid and safe? Why or why not?
  const char * HelloString() {
    return "Hello";
  }

(A) Yes. String literals are always copied when returned from a function, so it is safe to return one

(B) No. Any function that returns a string literal must be marked const

(C) Yes. String literals are valid for the lifetime of your program, so it is safe to return one

(D) No. The string "Hello" is local to this function and as such may result in corrupted memory

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

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

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

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

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

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

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

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

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

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

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

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

4. You should use an std::array from the C++ standard library (e.g., std::array<int, 10> my_array rather than a C-style array (e.g., int my_array[10]). Which of the following is NOT a reason why?

(A) std::array tracks size information, while C-style arrays require you to track size yourself

(B) std::array provides helper functions, such as .at or .back; C-style arrays do not

(C) std::array can be used in range-based for loops; C-style arrays can not

(D) C-style arrays will often decay into pointers when you pass them into a function, losing some type information

5. 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

6. 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

7. What functionality is NOT provided by Doxygen?

(A) Checks to determine if your code is tested

(B) Additional Markdown files that are formatted along with documentation

(C) Autogeneration of indeces

(D) Documentation of your code that resides in the code file itself

(E) All of these are provided by Doxygen

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

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

(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) There is no difference; they are the same

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

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

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

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

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

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

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

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

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

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

(C) We never plan to dereference the pointer

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