Multiple Choice Quiz

1. Which of the following is NOT a feature of std::unique_ptr?

(A) It gets automatically destroyed when it goes out of scope.

(B) It provides automatic memory management.

(C) Ownership can be transferred.

(D) It's pointer value can be copied into another unique_ptr.

2. Which of the following is NOT a difference between deterministic problems in your code and non-deterministic problems?

(A) In a debug build, deterministic problems can typically be replicated, but non-deterministic problems will often change symptoms.

(B) Non-deterministic problems are usually caused by invoking non-deterministic behavior, while deterministic problems are more typically issues with logic, syntax, or configuration.

(C) Deterministic problems can be replicated perfectly given identical inputs, but non-deterministic problems may change symptoms from one run to the next.

(D) Asserts can help narrow down the location of deterministic problems, but are useless for non-deterministic problems.

3. If a class has at least one virtual function, which cast can use this information for safer downcasting?

(A) dynamic_cast

(B) static_cast

(C) const_cast

(D) reinterpret_cast

4. What happens if you use const_cast to cast away the constness of an object that was originally defined as const and then modify it?

(A) The original object will remain unchanged.

(B) The behavior is undefined.

(C) An exception will be thrown.

(D) The program will have a segmentation fault.

(E) The object will be modified without any issue.

5. A std::shared_ptr can use the same operators as a raw pointer (e.g., * or ->). How is this accomplished?

(A) The operators all work by default for any class that has a pointer as its first member variable.

(B) The relevant operators are overloaded in the shared_ptr class.

(C) The shared_ptr class must be derived from raw pointers to keep this functionality.

(D) It requires shared_ptr to be built-in to the compiler to work, and cannot be implemented manually.

6. Which of the following debugging techniques is so time intensive that it should typically be attempted only after the other techniques fail to help you resolve the issue?

(A) Systematically remove (or comment out) sections of your program to find the minimal code that exhibits the problem.

(B) Add more related unit tests to understand the scope of your problem.

(C) Add asserts to test pre- and post-conditions for functions that you expect to be involved.

(D) Step backward through your code from the error, finding the earliest instance of the problem.

(E) Run your code through a debugger to see if it identifies the problem.

7. What does std::make_shared do?

(A) It makes a unique_ptr into a shared_ptr, allowing it to have more than one instance.

(B) It allocates a new object of the specified type, initializes it, and returns a shared_ptr to the new object.

(C) It creates an additional instance of a provided shared_ptr.

(D) It upgrades a weak_ptr into a shared_ptr.

(E) It converts any other type of existing pointer into a shared_ptr.

8. Which of the following is **NOT** true about the relationship between unit testing and "higher level" tests (e.g., integration tests, component tests)?

(A) Unit tests typically do not access external resources (e.g., a database), while higher level tests are more likely to.

(B) The distinction between these tests is often blurry and can vary between projects

(C) Unit tests can be used to "regression test" and detect if the program has changed. Higher level tests cannot be used this way.

(D) Higher level tests are generally slower

9. For which of the following is static_cast NOT appropriate?

(A) Converting between numeric data types (e.g., int to float).

(B) Converting between unrelated pointer types.

(C) Downcasting (from base to derived) when you're certain of the object's actual type.

(D) Upcasting (from derived to base).

10. Which of the following is an example of undefined behavior in C++?

(A) Calling sizeof on types that depend on system architecture or the compiler, like size_t

(B) An infinite loop with no side effects

(C) Having a return statement in a void function

(D) Creating a variable and then never using it

(E) Calling a function that has a return value and then discarding (i.e., not using) the returned value

11. Assume our API specifies the following integer exponentiation function declaration, and we have been asked to test it (this is a raised to the b power):

int Exponentiate(int a, int b);

Assuming the function declaration will not change, which of the following is not a useful test case?

(A) REQUIRE(Exponentiate(-1, 3) == -1);

(B) REQUIRE(Exponentiate(-1, 2) == 1);

(C) REQUIRE(Exponentiate(2, -1) == 0.5);

(D) REQUIRE(Exponentiate(3, 2) == 9);

(E) REQUIRE(Exponentiate(3, 0) == 1);

12. When committing code that you have debugged, which of the following should be bundled with a fix to that code?

(A) New features that you implemented that affect the same areas as the fix.

(B) Refactoring of any code that you identified during the fix.

(C) New test cases that would catch the problem if it occurred again.

(D) Fixes to other defects in your code.

(E) All of the above.

13. If you successfully compile your code, why might you still need to worry about syntax errors with this code?

(A) Syntax errors do not always cause compilation to halt.

(B) Syntax errors may arise at run time.

(C) Different compilers or different platforms may trigger syntax errors on compilation.

(D) Syntax errors are non-deterministic and as such may give you problems on future compilations.

(E) You don't -- once you get your code to compile, only other types of errors can be an issue.

14. When you create a std::unique_ptr you can provide a function to run on deletion. Why is this useful?

(A) It is an excess feature in the interface that has little practical utility.

(B) You must do this to make sure to delete the associated pointer.

(C) You can use this to ensure that no other pointers are referring to this object before deleting it.

(D) You can have it perform additional actions to manage resources, such as closing files or releasing sockets.

15. What will be the result of using reinterpret_cast to convert an integer pointer to a character pointer?

(A) It will retrieve the ASCII value of the integer.

(B) It will return a null pointer.

(C) It will give a compilation error.

(D) It will point to the memory address of the integer as if it were a character.

16. What do you need to do before a std::unique_ptr called ptr falls out of scope (assuming you are done with the pointed-to memory) to avoid memory leaks or corruption?

(A) Make sure to run ptr.delete();

(B) Make sure to run delete ptr;

(C) Nothing. It will take care of itself.

(D) Make sure to run ptr.reset();

17. What happens if you copy one std::shared_ptr to another?

(A) Both shared_ptrs point to different copies of the object.

(B) This is undefined behavior.

(C) Both shared_ptrs point to the same copy and he reference count is incremented.

(D) The original shared_ptr becomes null.

18. Which of the following is NOT a productive development practice for preventing bugs in your code?

(A) Add asserts to test pre-conditions and post-conditions in new functions.

(B) Always verify that new functionality doesn't break previous tests.

(C) Add all optimizations into the code from the beginning to ensure they are defect free.

(D) Iterative, bottom-up development.

(E) Each time you fix a bug, add a test to make sure a similar bug will be caught in the future.

19. What happens when you run std::move() on a unique_ptr value?

(A) The pointed-to memory stays where it is, but is marked as being allowed to be assigned (shifting ownership) to a different pointer.

(B) The pointed-to object is copied to a different position in memory and that new position is returned.

(C) The pointed-to object is moved to a specified position in memory and the unique_ptr's value is updated to this new position.

(D) The unique_ptr is converted into a raw pointer, but otherwise unmodified.

20. What is the advantage of a "time-traveling" debugger?

(A) They work with git repositories to trace back when in time a bug was introduced to your code.

(B) None. Time-traveling debuggers are purely theoretical and do not exist yet.

(C) They allow you to trace back how variables got the values they currently have without needing to restart a run.

(D) The produce graphs of variable values over time to help you identify unexpected correlations.

(E) They allow you to make temporary changes to debug your code that you can then rewind back to their original state.

21. Which of the following is a valid definition of undefined behavior?

(A) Code that is unnecessarily confusing

(B) Code that has multiple valid meanings according to the standard, and each compiler much pick one and specify it in their documentation

(C) Code that has multiple valid meanings according to the standard, and a compiler is allowed to choose any of them

(D) Code that has no official meaning according to the standard

(E) Code that results in a warning, but not an error

22. The following code snippet of a function contains undefined behavior.
Identify the cause of undefined behavior and where it arises.

  Line 1) void MyFunction(){
  Line 2) uint8_t x;
  Line 3) x += 10000;
  Line 4) return;
  Line 5) }

(A) Line 2 - The variable x is declared but not initialized

(B) Line 3 - The variable x is accessed before being initialized

(C) Line 3 - The addition causes an overflow

(D) Line 4 - The function is void yet has a return statement

(E) Line 4 - The function contains a return statement without a value

23. Why should you use std::make_unique instead of new when constructing a unique_ptr?

(A) To ensure exception safety and efficiency.

(B) To manually manage memory.

(C) To delay object creation until first usage.

(D) They are functionally identical and it doesn't matter.

24. If you trigger undefined behavior by writing outside the bounds of an array, which of the following results is possible according to the C++ standard?

(A) Memory is corrupted.

(B) A segmentation fault occurs.

(C) An exception is triggered.

(D) Your computer shuts down.

(E) Any of the above are technically allowed.

25. Which if the following is NOT a reason that assertions are helpful in your code?

(A) They can be used to bring out-of-range function parameters back into range to restore code correctness.

(B) They can be easily removed and thus have no negative impact on released code.

(C) They interact well with debuggers, which help your trace back why an assertion failed.

(D) They will sometimes catch non-deterministic errors, helping you narrow down where they occurred.

(E) They can clearly identify that a problem exists before a regular crash or incorrect output occurs.

26. Which of the following is true about undefined behavior?

(A) In your code, it is impossible to test if undefined behavior has occurred

(B) Undefined behavior is an error

(C) One major goal of the C++ standard is to eliminate all undefined behavior from the language

(D) Undefined behavior only occurs at runtime

(E) The C++ standards contain a list of all undefined behavior

27. Which of the following reasons is NOT motivation behind unit testing?

(A) Unit testing makes us think about our API design and the accessibility of our functions and classes

(B) If our code has a bug, unit tests can help us pinpoint where the bug is -- or is not

(C) Unit testing builds trust in our code, improving our confidence that our changes aren't breaking old code

(D) Unit tests provide a solid foundation of reliability so we can create higher level tests (e.g., integration tests) with more confidence

(E) Unit testing provides performance benchmarks of how our code might perform out in the real world

28. What happens when the only two shared_ptrs pointing to an object both go out of scope?

(A) Undefined behavior occurs.

(B) Reference count goes to zero and the object is deleted.

(C) Reference count goes to 1 but the object remains.

(D) The object is deleted twice.