C++ Advanced · exercise 03

Lock-free data structures

Complete a single-producer single-consumer ring buffer.

Guided steps

1.push stores a value and advances the head; it fails when the ring is full.
2.pop reads from the tail and fails when head equals tail.
3.Print each popped value, then the empty result.

Your code

#include <atomic>
#include <iostream>

template <typename T, std::size_t N>
class Ring {
public:
  bool push(T value) {
    const std::size_t head = head_.load(std::memory_order_relaxed);
    const std::size_t next = (head + 1) % N;
    if (next == tail_.load(std::memory_order_acquire)) return false;
    slots_[head] = value;
    // TODO: publish the new head with release ordering.
    return true;
  }

bool pop(T& out) {
    const std::size_t tail = tail_.load(std::memory_order_relaxed);
    if (tail == head_.load(std::memory_order_acquire)) return false;
    out = slots_[tail];
    tail_.store((tail + 1) % N, std::memory_order_release);
    return true;
  }

private:
  T slots_[N]{};
  std::atomic<std::size_t> head_{0};
  std::atomic<std::size_t> tail_{0};
};

int main() {
  Ring<int, 4> ring;
  ring.push(10);
  ring.push(20);
  int value = 0;
  while (ring.pop(value)) std::cout << "pop " << value << "\n";
  std::cout << "empty " << (ring.pop(value) ? "no" : "yes") << "\n";
  return 0;
}

Your code is saved in this browser after every run and restored next time.