Multiple Choice Quiz

1. Which scenario would MOST likely require profiling?

(A) A game's frame rate drops significantly during complex scenes

(B) A program's output text has is formatted incorrectly

(C) A data analysis tool crashes unexpectedly on some input files

(D) A function's logic is difficult to read

(E) A compiler warning suggests a potential type conversion issue

2. How do move semantics contribute to the efficiency of classes with value semantics?

(A) They allow the resources of temporary objects to be transferred rather than copied.

(B) They guarantee that no actual copies will ever occur.

(C) They enforce deep copies to avoid the need to ever share resources.

(D) They eliminate the need to manually define destructors as resources are recycled instead of freed.

(E) They enable the compiler to inline all member functions automatically.

3. What is a common pitfall when writing a microbenchmark in C++?

(A) Activating the timing code may alter how the CPU processes instructions, altering the algorithms being tested.

(B) The operating system may require the code to be compiled in debug mode.

(C) The compiler might optimize away the code being benchmarked if its results are not used.

(D) Clocks are only guaranteed to be accurate to the second, while many tests you need to time will be much faster than that.

(E) The use of <chrono> may introduce significant overhead in the timing measurements.

4. Which standard C++ library provides time-based tools that can be used for benchmarking?

(A) <benchmark>

(B) <time>

(C) <chrono>

(D) <measure>

(E) <record>

5. When should you avoid marking a function as constexpr?

(A) When the function will sometimes need to be called at run time

(B) When the function is called from many different places in your code

(C) When the function has a recursive call to itself

(D) When the function is overly long

(E) When the function needs to interact with files

6. There are several things to make sure you understand when benchmarking, which of the following is NOT a reasonable goal?

(A) Ensuring that you benchmark your code via short, almost trivial use cases to save time

(B) Ensuring that you understand how your benchmarking code interacts with the compiler's optimizations

(C) Ensuring that your benchmarking code does not needlessly inflate your timing results

(D) Ensuring that you understand which portions of your code you are actually benchmarking

(E) Ensuring that you know which compiler flags you are using and how they will affect benchmarking

7. What is small string optimization?

(A) Handling small strings in existing space without allocating extra memory

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

(C) Compressing strings to require less memory

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

(E) Handling small strings using preallocated memory shared among strings

8. Andrei Alexandrescu's small 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) This swap ensured that the strings would always be able to fit into cache

(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) Remaining size is guaranteed to never be zero

(E) All of the above

9. Given a string representation that tracks string length (8 bytes), string capacity (8 bytes) and a pointer to the string (8 bytes), how long of a string can you store using small-string optimization (SSO)?

(A) A maximum of 8 characters (by using the 8 bytes from pointer, but keeping size and capacity intact)

(B) A maximum of 16 characters (by using the 16 bytes from capacity and pointer, but keeping size intact)

(C) A maximum of 23 characters (by keeping just one byte for remaining size that can double as the null terminator when remaining size is zero)

(D) A maximum of 24 characters (using all 24 bytes)

(E) There is no limit to the size of an SSO string.

10. Why should you try to avoid branching in highly optimized code?

(A) CPUs engage in speculative execution; an incorrect branch prediction can be a big speed hit.

(B) Branches force the code to be interpreted at runtime

(C) Branches do not have a pattern to them, dramatically increasing the amount of code generated.

(D) Branches make code sequential and prevent the use of multiple cores

(E) It is not possible to optimize code that has branches in it.

11. Which of the following is a valid use of constexpr in C++?

(A) Limiting a function so that it can only be called at compile time, not at run time.

(B) Allowing a that same variable to be defined with different values in two different compilation units.

(C) Declaring a variable that can only be used at compile time, but not at run time.

(D) Postpone initialization of a variable until the linking stage of compilation.

(E) Defining a function that returns a value computable at compile time when given constant expressions.

12. If we profile a scope that has a lot of code and see that it is taking longer than expected, which of the following is NOT typically an effective next step for identifying the problem?

(A) Divide up the scope into a set of sub-scopes and time each one to narrow down the problem

(B) Pick a function call that you think might be the problem and time it to test your suspicion

(C) Run your profiler additional times to get average values, in case the original numbers were outliers

(D) Track the memory allocations occurring in that function to see if any of them are the problem

(E) Pick any function that is called and start optimizing it

13. Which of the following factors would make it impossible to effectively profile a function?

(A) User interaction, especially code that needs to wait for a user response

(B) Multi-threading, since it produces non-deterministic execution

(C) Code marked constexpr, since we don't know if it will run at compile-time or run-time

(D) Exceptions, since they may radically change the flow of code

(E) Virtual functions, since we may not know which version of a function will be run

14. When an l-value argument is passed by value into a function parameter, which of the following statements is true?

(A) The function can modify the original value of the argument that was passed in

(B) The original object's destructor is called when the function parameter goes out of scope

(C) It is always less memory efficient than passing by reference

(D) It is always more memory efficient than passing by reference

(E) The function receives a copy of the argument

15. What does it mean if a function is marked constexpr?

(A) The function must be able to be run at compile time if all arguments are known

(B) The function can only be called using constexpr arguments

(C) If the function cannot be run at compile time, it will be executed on a separate thread to improve performance

(D) The function can include dynamic memory allocation and deallocation

(E) The function is automatically considered to be marked [[nodiscard]] as well

16. Why is it important to profile your code before manually optimizing it?

(A) Because optimizations should be based on actual performance data, not assumptions

(B) Because profiling will often remove the need for manual optimization

(C) Because profiling your code will trigger automatic optimizations to make it faster

(D) Because most compilers require a profile trace to know how to handle more complex optimizations

17. Which of the following do you need to worry about when instrumenting your code for profiling?

(A) Instrumented code will often introduce many new bugs into your program

(B) Instrumented code can only record the number of times a function is called, not how long each time takes

(C) Instrumented code can only record how long a function takes, not the number of times it is called

(D) Instrumented code needs to be able to do all data analysis internally, outputting only a final result

(E) Instrumented code may run slower overall due to the overhead of instrumentation

18. Which of the following features helps to facilitate efficient pass-by-value for classes with a large memory footprint?

(A) Templates

(B) Use of the commands new and delete

(C) Range-based for loops

(D) Lambda expressions

(E) Move semantics

19. Which of the following is a benefit of benchmarking your code?

(A) Exposing vulnerabilities that attackers could use to exploit your code

(B) Ensuring that your code can handle various edge cases

(C) Identifying race conditions in your concurrent code

(D) Pinpointing memory leaks in your code

(E) Identifying the parts of your code that will see the most benefit from optimization

20. When deciding between passing-by-value and passing-by-reference, which of the following is NOT going to be relevant?

(A) Whether the original object needs to be altered in the function

(B) Whether the class has move semantics implemented

(C) The memory footprint of the object

(D) Whether the function being called is a const member function

(E) How frequently the parameter will need to be accessed inside the function

21. What is the direct result of profiling your code?

(A) Improvements in the efficiency of your code

(B) Reductions in the memory usage of your code

(C) Data on the timing of different portions of your code

(D) Reductions in the energy usage needed to run your code

22. What is one advantage of providing a constexpr constructor in a class?

(A) It automatically makes all member functions constexpr as well.

(B) It forces all instances of the class to be immutable.

(C) It requires that the class be allocated statically.

(D) It enables objects to be constructed at compile time when provided with argument values known at compile time.

(E) It guarantees that no runtime overhead will occur for that class.

23. Assuming we have the function:
  constexpr int add(int x, int y) {
    return x + y;
  }
What would happen if we call:
  add(std::cin.get(), 3);

(A) It will run the function at run-time instead of compile time, as if it were not marked constexpr

(B) It will still be run at compile time, but assume a zero for the first argument

(C) It will wait for an input at compile time so that the function can be run appropriately

(D) It will give a run-time error when the function is called since it could not be compiled properly

(E) It will give a syntax error since the first argument cannot be known at compile time

24. If a variable is declared as constexpr, will its value be set at compile time?

(A) Yes, always

(B) Usually, but it is only guaranteed if the value is used elsewhere at compile time

(C) Only if it is also marked static

(D) Only if it is used in a header file

(E) Usually, but it is up to the compiler and the programmer can never guarantee that it will.

25. Which statement correctly distinguishes between const and constexpr?

(A) constexpr and const are interchangeable in all contexts.

(B) const indicates a variable's value cannot be modified (but it might be initialized at runtime), whereas constexpr requires the value of a variable to be able to be computed at compile time.

(C) constexpr indicates a variable's value cannot be modified (but it might be initialized at runtime), whereas const requires the value of a variable to be able to be computed at compile time.

(D) const can only be applied to variables, while constexpr can only be used with functions.

(E) constexpr variables can only be accessed at compile time, whereas const variables can only be accessed at run time.

26. Many std::string implementations maintain an instance of the empty string rather than just using a null pointer. Why?

(A) It allows empty strings to be garbage collected, reducing memory leaks.

(B) It provides a built-in mechanism for overloading operators specifically for empty strings.

(C) It reduces the amount of memory needed to maintain strings.

(D) It eliminates the need for a conditional to test if the string is empty.

(E) The use of null pointers is fundamentally a bad programming practice.

27. If you want to use value semantics on objects of a custom class, which of the following is most important to implement?

(A) A virtual destructor

(B) A set of data accessors

(C) A copy constructor

(D) An operator<< for printing

(E) A default constructor

28. Is it better to benchmark in debug or release mode?

(A) There is no meaningful difference between the two when benchmarking

(B) Release mode, to measure the efficiency of the most optimized version of the code

(C) Debug mode, to catch errors via checks like assert

(D) You should use neither debug nor release, but instead a profiling mode that includes both compilation symbols and asserts

29. Some implementations of std::string use a "copy on write" technique where copies keep pointing to the original memory for the string sequence, but also maintain a reference count of how many instances exist. Only once a string needs to be changed is it actually copied first. Why?

(A) It permits the compiler to handle all string copying at compile time, resulting in zero runtime overhead.

(B) This technique reduces the overall number of string copies that need to be maintained.

(C) It allows modifications in one copy to automatically update all copies, eliminating the need for data synchronization.

(D) Copy-on-write requires less bookkeeping and is much simpler to implement.

(E) Deferring copying a string allows the CPU to heat up first, making it run faster.

30. Some implementations of std::string use a "copy on write" (COW) technique where copies keep pointing to the original memory for the string sequence, but also maintain a reference count of how many instances exist. Why have most modern implementations moved away from this COW technique?

(A) Because C++ move semantics provide efficient resource transfers and COW introduces thread-safety issues due to shared mutable state.

(B) Because copy-on-write has turned out to result in slower performance by adding unavoidable reference counting overhead.

(C) Because copy-on-write implementations can lead to memory leaks by keeping shared buffers alive longer than necessary.

(D) Because copy-on-write requires strings to be immutable, which conflicts with the mutable design of std::string.

(E) Because copy-on-write prevents modern compilers from optimizing code through inlining and other techniques.