CT 301 Exam 2 Topics

Scope

Exam 2 covers the Homework 2 material: the implementation of ct::Vector<T>. Anything from the assignment is fair game, including both the interface you implemented and the reference implementation provided to you. You should be able to read, explain, and reason about any part of it, not only how to use the vector but how its internals work and why. The list below is the full set of topics it can draw on, each with where to read.

1. Memory management on the free store

• The two ways to manage a buffer: ordinary new[]/delete[] versus the decoupled form the vector uses, ::operator new for raw bytes, placement new to construct elements in place, explicit destruction (std::destroy_n, std::destroy_at, or an explicit ~T() call), and ::operator delete to free.
• What allocate() and deallocate() each do.
• Why allocation and construction are separated, and how that lets capacity exceed size.
• Leaks, double-free, dangling pointers, and the cleanup order in the destructor (clear() then deallocate()).

Where to read: L7 · Tour §1.7, §5.2, §15.2 · PPP Ch. 15 · learncpp: 12.7, 19.1, 15.4 (placement new / ::operator new: no direct lesson)

2. Pointers, arrays, and iterators

• The buffer as contiguous memory; pointer arithmetic; why p[i] equals *(p + i).
• Iterators as raw pointers: begin/end, cbegin/cend.
• Reverse iterators built on std::reverse_iterator: rbegin/rend, crbegin/crend.
• const_iterator and const-correctness.
• Turning an iterator into an index with static_cast<size_type>(pos - begin()).

Where to read: L7, L8 · Tour §1.7, §15.3-15.4 · PPP Ch. 15-16 · learncpp: 12.7, 17.9

3. Essential operations: the rule of 5/7

• The destructor.
• Copy constructor and copy assignment as a deep copy (including copy-and-swap).
• Move constructor and move assignment that steal the buffer and leave the source empty, marked noexcept.
• Shallow versus deep copy, and the double-free bug a shallow copy causes.
• Self-assignment.
• The assign() overloads and swap() (member and non-member).

Where to read: L9 · Tour Ch. 6, §16.6 · PPP Ch. 17 · learncpp: 14.14, 21.12, 21.13, 22.3

4. Element access and operators

• operator[] (no bounds check) versus at() (throws std::out_of_range).
• front(), back(), and data().
• The non-member operator==.

Where to read: L6, L9 · Tour Ch. 6, §5.2.2 · PPP Ch. 17 · learncpp: 21.9, 21.x (operators)

5. Capacity and growth

• size(), capacity(), empty(), and max_size().
• reserve(): allocate a new buffer, move the elements over (std::uninitialized_move_n), destroy the old ones, and free.
• grow_if_needed() and the growth strategy: when capacity grows and by how much.
• shrink_to_fit().

Where to read: L7 · Tour §5.2, §15.3 · PPP Ch. 15 · learncpp: no direct lesson (manual capacity and growth are vector-internal)

6. The full Vector interface: constructors and modifiers

• Constructors: default, count, count-and-value, initializer-list, range (first/last), copy, and move.
• Modifiers: clear, push_back (const& and &&), emplace_back, emplace, pop_back, insert (single value, count-and-value, range, initializer-list), erase (single and range), and resize (with and without a fill value).
• How insert and emplace place an element at a position using std::rotate.

Where to read: L7, L9 · Tour §5.2.2, Ch. 6 · PPP Ch. 15, 17 · learncpp: initializer-list constructors are covered in passing; the modifier set is vector-specific

7. Templates and member types

• ct::Vector<T> as a class template, and the type parameter T.
• The member type aliases (using): value_type, size_type, iterator, const_iterator, reference, and the rest.
• Using the vector with more than one element type.

Where to read: L10 · Tour Ch. 7 · PPP Ch. 18 · learncpp: 11.6, 13.13

8. Exceptions

• at(), front(), and back() throw std::out_of_range.
• reserve() and resize() throw std::length_error when a request would exceed max_size().
• try/catch, and which operations can throw.

Where to read: L10 · Tour §4.2 · PPP Ch. 18 · learncpp: 27.2

9. Idioms used in the implementation

• noexcept, explicit, static_cast, std::move, std::forward (perfect forwarding in emplace and emplace_back), and std::rotate.
• The uninitialized-memory helpers: std::uninitialized_copy, std::uninitialized_fill_n, std::uninitialized_move_n, std::uninitialized_value_construct_n.
• The single-header design: the include guard CT_VECTOR_H, the ct namespace, and template <typename T>.

Where to read: L9, L10 · Tour Ch. 6, §16.6, Ch. 7 · PPP Ch. 17-18 · learncpp: 22.3, 27.2 (noexcept, perfect forwarding: no single lesson)

10. The driver

• The driver.cpp work you wrote (the total() function and the data it processes), and reading values back out of a populated vector.

Where to read: Applies areas 1-9; no separate reading (your own code that uses the vector).

Where to read (at a glance)

The same mapping as above, gathered in one place.

Also from the lectures (beyond the HW2 code)

These topics are taught in lectures 7 through 10 but are not part of the ct::Vector implementation. Review them as context. They are secondary to the areas above, which is where the exam concentrates.

• Smart pointers and RAII. std::unique_ptr and std::shared_ptr as the managed-memory counterpart to the manual new/delete you wrote in HW2.
  L10 · Tour Ch. 6, §15.2 · PPP Ch. 18 · learncpp: 22.5, 22.6

Section numbers (§) refer to A Tour of C++ 3rd ed. (required); chapter numbers in the PPP references are Programming: Principles and Practice using C++ 3rd ed. (optional).