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. The string "Hello" is local to this function and as such may result in corrupted memory

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

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

2. What types of optimizations do C++ compilers give you if you don't specify an optimization level?

(A) Only quick optimizations (that do not slow compilation) are turned on, the rest are turned off

(B) The specific optimizations vary substantially from one compiler to another

(C) All optimizations that don't affect debugging are turned on, the rest are turned off

(D) All optimizations are enabled by default (you must disable them if you don't want them)

(E) Most optimizations are disabled

3. When should you use a standard library algorithm instead of writing a for loop to do the same task?

(A) If the for loop would be substantially longer than the standard-library algorithm

(B) If the algorithm is too complicated to write quickly as a for loop

(C) Every time an appropriate algorithm already exists in the standard library

(D) If the for loop would take more than one line

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

(A) Because new and delete are deprecated

(B) To simplify debugging

(C) Because smart pointers are always faster

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

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

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

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

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

(D) All of these will compile

(E) None of these will compile

6. What is the output of the following code snippet?
  std::vector<int> vec{3, 1, -2};
  auto rng = vec
    | std::views::transform([](int j){ return (j % 2 == 0) ? j : 2 * j;})
    | std::views::transform([](int j){ return j*j;});
  for(auto i : rng){
    std::cout << i << " ";
  }
  std::cout << std::endl;

(A) "36 4 4"

(B) "9 1 16"

(C) "18 2 4"

(D) "9 1 8"

7. What functionality is NOT provided by Doxygen?

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

(B) Checks to determine if your code is tested

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

(D) All of these are provided by Doxygen

8. What is small string optimization?

(A) Dedicating heap space to optimize empty strings ("")

(B) Compressing strings to require less memory

(C) Handling short strings using preallocated memory shared among strings

(D) Handling short strings without allocating extra memory

(E) Splitting longer strings into multiple shorter substrings, with some substrings being shared

9. 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) 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

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

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

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