C++ Quiz

1. Why should you prefer '\n' to std::endl in most output?

• std::endl doesn't work on Windows
• std::endl also flushes the stream, which is slower
• '\n' adds two newlines
• They're identical

Use std::endl only when you really need the flush (lesson 03).

2. What does int b{3.9}; do?

• Stores 3
• Stores 4
• Fails to compile: brace initialisation forbids narrowing
• Stores 3.9

int a = 3.9; would compile and silently truncate (lesson 04).

3. What is the type of auto name = "Sam";?

• std::string
• const char*
• char
• std::string_view

String literals are C-style arrays; write std::string{"Sam"} or "Sam"s for a std::string (lesson 04).

4. What's the difference between const and constexpr variables?

• There is none
• constexpr values must be known at compile time; const values may come from run time
• const is only for pointers
• constexpr variables can be modified

(lesson 05)

5. After std::cin >> n; reads a number, why might the next std::getline return an empty string?

• getline can't follow >>
• The newline after the number is still waiting in the input
• n was not initialised
• The stream is in a fail state

Skip it with std::cin >> std::ws first (lesson 07).

6. Which of these compares two std::strings by content?

• a == b
• strcmp(a, b)
• a.equals(b)
• &a == &b

Unlike C strings, std::string overloads the comparison operators (lesson 08).

7. In for (auto x : v) x *= 2;, what happens to v?

• Every element is doubled
• Nothing: x is a copy of each element
• A compile error
• Only the first element changes

Use auto& to modify the elements (lesson 11).

8. How should a function take a large std::vector it only reads?

• By value
• By pointer
• By const reference (or as a std::span)
• By rvalue reference

No copy, and the function can't modify it (lessons 14 and 19).

9. What does std::move(name) do by itself?

• Copies the string
• Deletes the string
• Casts name so it can be moved from; the actual move happens when it's passed or assigned
• Moves the string to the heap

Afterwards, don't rely on the moved-from object's value (lesson 14).

10. What's the danger of a std::string_view?

• It doesn't own its data, so it can dangle if the string it refers to is destroyed
• It's slower than std::string
• It can't be passed to functions
• It always copies the text

Use views for parameters; be careful storing them (lesson 19).

11. What does m["key"] do on a std::map when the key is missing?

• Throws an exception
• Returns an empty optional
• Inserts the key with a default-constructed value
• Returns nullptr

Use contains, find or at to look without inserting (lesson 21).

12. When does iterating a std::unordered_map give a predictable order?

• Always alphabetical
• Always insertion order
• Never guaranteed: the order is unspecified
• Only for integer keys

Use std::map or sort the results when order matters (lesson 21).

13. What does end() of a container point to?

• The last element
• One position past the last element
• The first element
• nullptr

Dereferencing end() is undefined behaviour (lesson 23).

14. In [&total, limit](int v) { … }, how are the variables captured?

• total by reference, limit by copy
• Both by reference
• Both by copy
• total by copy, limit by reference

(lesson 24)

15. What makes C++20 views "lazy"?

• They sort the data first
• They compute elements only when the elements are requested
• They copy the data into a new container
• They run in a separate thread

Which is why views::iota(1) can be infinite (lesson 26).

16. Which statement about owning raw pointers is the modern guideline?

• Use new and delete for every object
• Raw pointers should never own; containers and smart pointers own objects
• Smart pointers are slower and should be avoided
• Always use shared_ptr

(lessons 27–29)

17. Which smart pointer should you use by default for a single owner?

• std::unique_ptr, created with std::make_unique
• std::shared_ptr
• std::weak_ptr
• std::auto_ptr

unique_ptr has no overhead compared with a raw pointer (lesson 29).

18. What does RAII guarantee?

• Objects are created on the heap
• Resources are released by destructors when objects go out of scope, even when exceptions are thrown
• Variables are always initialised
• Memory is garbage collected

(lesson 30)

19. What does const after a member function's parameter list mean?

• The function returns a constant
• The function doesn't modify the object, so it can be called on const objects
• The function can't be overridden
• The function is evaluated at compile time

(lesson 31)

20. In what order are members initialised?

• In the order of the initialiser list
• Alphabetically
• In the order they're declared in the class
• In reverse order of declaration

Compilers warn when the initialiser list order differs (lesson 32).

21. Why mark a single-argument constructor explicit?

• To prevent it being used as an implicit conversion
• To make it faster
• To allow default arguments
• To make it a template

(lesson 32)

22. What does auto operator<=>(const T&) const = default; provide?

• Only ==
• All six comparison operators, comparing members in order
• Only <
• Stream output

(lessons 20 and 34)

23. What is the "rule of zero"?

• Classes should have no members
• Prefer classes whose members manage themselves, so you write no destructor, copy or move operations
• Never use zero as a default value
• Constructors should take zero arguments

(lessons 30 and 35)

24. A base class is used polymorphically through pointers. What must it have?

• A static member
• A template parameter
• A virtual destructor
• A friend function

Otherwise deleting a derived object through a base pointer is undefined behaviour (lesson 37).

25. What does override do?

• Makes a function virtual in the base class
• Makes the compiler check that the function really overrides a base-class virtual function
• Hides the base-class function
• Prevents further overriding

final prevents further overriding (lesson 37).

26. What makes a class abstract?

• Having no data members
• Having at least one pure virtual function (= 0)
• Being declared with struct
• Having a private constructor

Abstract classes can't be instantiated (lesson 38).

27. Where should template definitions usually go?

• In a .cpp file, with only declarations in the header
• Entirely in the header, so the compiler can instantiate them
• In a separate library
• Templates don't need definitions

(lessons 39–40)

28. What do concepts add to templates?

• Run-time type checks
• Named requirements on template arguments, with clear errors and overloading by capability
• Virtual functions
• Automatic memory management

(lesson 41)

29. When is std::optional a better choice than throwing an exception?

• When "no result" is a normal, expected outcome, such as a failed search
• When the error must stop the program
• When the error occurs in a constructor
• Never

(lessons 42–43)

30. What is a data race?

• Two threads finishing at the same time
• Two threads accessing the same data concurrently, at least one writing, without synchronisation
• A thread that never finishes
• Using too many threads

Data races are undefined behaviour; protect shared data with mutexes or atomics (lesson 47).