C++ Programming

Q1 (10)

(a) (6) — 1 mark each for the six specials being present and correct.

#include <cstddef>
#include <algorithm>
#include <utility>
 
class Buffer {
    int*   data_ = nullptr;
    size_t size_ = 0;
public:
    explicit Buffer(size_t n) : data_(new int[n]{}), size_(n) {}   // param ctor
 
    ~Buffer() { delete[] data_; }                                  // dtor
 
    Buffer(const Buffer& o) : data_(new int[o.size_]), size_(o.size_) {   // copy ctor
        std::copy(o.data_, o.data_ + size_, data_);
    }
 
    Buffer& operator=(const Buffer& o) {                           // copy assign (strong)
        Buffer tmp(o);          // copy first — if new[] throws, *this untouched
        swap(tmp);
        return *this;
    }
 
    Buffer(Buffer&& o) noexcept                                    // move ctor
        : data_(o.data_), size_(o.size_) {
        o.data_ = nullptr; o.size_ = 0;
    }
 
    Buffer& operator=(Buffer&& o) noexcept {                       // move assign
        if (this != &o) {
            delete[] data_;
            data_ = o.data_; size_ = o.size_;
            o.data_ = nullptr; o.size_ = 0;
        }
        return *this;
    }
 
    void swap(Buffer& o) noexcept {
        std::swap(data_, o.data_);
        std::swap(size_, o.size_);
    }
};

Why: the class manages a raw resource, so the compiler-generated shallow copies would double-free — Rule of Five requires all five to be user-defined.

(b) (2) Strong guarantee = if the operation throws, the object is left in its original state (commit-or-rollback), no leaks. Technique: copy-and-swap — the potentially-throwing allocation (Buffer tmp(o)) happens before any modification of *this; the swap is noexcept. If new[] throws, *this is unchanged. (1 for meaning, 1 for identifying copy-and-swap.)

(c) (2) std::vector grows by allocating a bigger buffer and moving elements. It only uses the move constructor during reallocation if the move is noexcept; otherwise it falls back to copying to preserve the strong guarantee (a throwing move mid-reallocation could leave the vector corrupted with no rollback). So a non-noexcept move silently degrades vector<Buffer> growth to O(n) copies. (1 for the fallback-to-copy fact, 1 for the reallocation strong-guarantee reason.)

Q2 (10)

(a) (3) With mutual shared_ptr links, each node's control block count includes the other node's reference. In a 2-node cycle A↔B: external count on each is 1 (external) + 1 (from peer) = 2. Destroying the last external shared_ptr drops each to 1, not 0, so neither destructor runs → memory leak (cyclic reference). (1 count trace + 2 leak explanation.)

(b) (4)

struct Node {
    std::vector<std::shared_ptr<Node>> children;  // ownership (strong)
    std::vector<std::weak_ptr<Node>>   backlinks; // back-edges (weak, non-owning)
 
    void visitParent(size_t i) {
        if (auto p = backlinks[i].lock()) {  // lock() → shared_ptr or nullptr
            /* use p safely */
        }
    }
};

The back-edge (child → parent, the "return" direction that closes the cycle) becomes weak_ptr. Access is via .lock(), which returns a valid shared_ptr if the object is alive, else nullptr. (2 for direction/design, 2 for .lock() usage.)

(c) (3)

std::shared_ptr<Node> s = std::move(p);   // unique → shared: converting ctor

The reverse is impossible because a shared_ptr may share ownership with other shared_ptrs (ref count > 1); you cannot extract exclusive ownership without knowing you are the sole owner, and shared_ptr provides no release(). unique_ptr guarantees sole ownership, so promoting up is always safe. (1 line + 2 reasoning.)

Q3 (12)

(a) (5)

#include <type_traits>
 
template<class... Ts>
concept AllArithmetic = (std::is_arithmetic_v<Ts> && ...);
 
template<class... Ts>
    requires AllArithmetic<Ts...>
auto sum(Ts... args) {
    return (args + ...);   // unary right fold over +
}

Why: (args + ...) is a fold expression expanding to a+(b+(c...)). The concept uses a fold over && to require every parameter arithmetic. (2 fold, 2 concept, 1 correct constraint syntax.)

(b) (4)

#include <type_traits>
#include <iostream>
 
template<class T>
auto print_size(const T& c) -> decltype(c.size(), void()) {   // enabled if .size() valid
    std::cout << c.size();
}
void print_size(...) {                                        // fallback
    std::cout << "no size";
}

Or std::enable_if_t<...>. Why: the trailing decltype(c.size(), void()) is ill-formed for types without .size(), so substitution failure removes that overload — not an error (SFINAE); the ellipsis overload wins. (3 SFINAE mechanism + 1 working overload set.)

(c) (3)

template<class T> struct Wrapper {
    static constexpr bool is_pointer = false;
    T value;
};
template<class T> struct Wrapper<T*> {   // partial specialization
    static constexpr bool is_pointer = true;
    T* value;
};

Inspect Wrapper<X>::is_pointer. (2 partial spec syntax + 1 correct member.)

Q4 (10)

(a) (5)

std::mutex m;
std::condition_variable cv;
std::queue<int> q;
bool done_ = false;
 
void consumer() {
    for (;;) {
        std::unique_lock<std::mutex> lk(m);
        cv.wait(lk, []{ return !q.empty() || done_; });   // predicate form
        if (q.empty() && done_) break;
        int v = q.front(); q.pop();
        lk.unlock();
        /* process v */
    }
}

Predicate form is preferred because it guards against spurious wakeups and lost wakeups: wait re-checks the predicate on every wake, and if the condition is already true before waiting it returns immediately without blocking. Plain wait would block unconditionally, risking a missed notification. (3 for correct predicate wait, 2 for spurious/lost wakeup explanation.)

(b) (3) Producer sets done_ under the lock then calls cv.notify_all() (or notify_one). Consumer's predicate !q.empty() || done_ becomes true, drains remaining items, then exits when q.empty() && done_. Shared state that must be under the mutex: the queue q and the done_ flag (both written by producer, read by consumer). (1 clean termination, 1 notify, 1 correct shared state.)

(c) (2) fetch_add with memory_order_relaxed guarantees only atomicity of the increment — no ordering of surrounding memory operations. memory_order_acq_rel additionally establishes acquire on read and release on write, synchronizing other memory accesses (happens-before). Relaxed is safe when the counter is a pure statistic whose value gates nothing else, e.g. counting completed events with no dependent reads (final read done after all threads joined). (1 distinction + 1 safe scenario.)

Q5 (8)

(a) (3)

std::vector<size_t> lengths;
lengths.reserve(words.size());
std::transform(words.begin(), words.end(),
               std::back_inserter(lengths),
               [](const std::string& w){ return w.size(); });

(2 transform + back_inserter, 1 lambda.)

(b) (2)

size_t total = std::accumulate(words.begin(), words.end(), size_t{0},
    [](size_t acc, const std::string& w){ return acc + w.size(); });

Why: init value typed size_t{0} prevents int accumulation overflow/truncation.

(c) (3)

bool allNonEmpty = std::all_of(words.begin(), words.end(),
    [](const std::string& w){ return !w.empty(); });

[=] copies minLen into the closure (snapshot at creation, independent of later external changes); [&] captures by reference (reads the live variable, reflects later changes, but dangles if minLen outlives its scope while the lambda persists). (2 all_of + lambda, 1 capture distinction.)

[
  {"claim":"Q3a sum fold over (1,2,3,4) = 10","code":"result = (1+2+3+4)==10"},
  {"claim":"Q1c reallocation doubles capacity, moves preserve size: vector of 5 stays 5","code":"n=5; result = n==5"},
  {"claim":"Q2a two-node cycle each ref count drops from 2 to 1 (nonzero -> leak)","code":"external=1; peer=1; after=external+peer-external; result = after==1 and after!=0"},
  {"claim":"Q5b total chars of ['ab','cde',''] = 5","code":"result = sum(len(x) for x in ['ab','cde',''])==5"}
]