Wat is een circular buffer (ring buffer) en wanneer zou je er een gebruiken?

Question

Accepted Answer

Een **circular buffer** is een array met vaste grootte die wordt behandeld alsof de uiteinden in een ring zijn verbonden. Twee indices — **head** (lezen) en **tail** (schrijven) — vorderen en verpakken zich met behulp van modulo-rekenkunde, wat een O(1) FIFO-wachtrij oplevert **zonder toewijzing** na creatie.

## Waarom het belangrijk is

```text
capacity 5, after writing A,B,C,D and reading A,B:
index:  0   1   2   3   4
      [ . ][ . ][ C ][ D ][ . ]
              head^       tail^   (tail wraps to 0 next write)
```

## Code

```python
class RingBuffer:
    def __init__(self, n):
        self.buf = [None]*n
        self.head = self.tail = self.size = 0
        self.cap = n
    def enqueue(self, x):                  # O(1)
        if self.size == self.cap: raise Exception("full")
        self.buf[self.tail] = x
        self.tail = (self.tail + 1) % self.cap   # wrap
        self.size += 1
    def dequeue(self):                     # O(1)
        x = self.buf[self.head]
        self.head = (self.head + 1) % self.cap    # wrap
        self.size -= 1
        return x
```

| Bewerking | Tijd |
|---|---|
| enqueue / dequeue | O(1) |
| ruimte | O(n) vast |

## Wanneer gebruiken

- **Streaming / audio / video buffers** — begrensd, constant doorvoer.
- **Producer–consumer** pijplijnen met backpressure.
- **De laatste N events loggen** (oudste overschrijven).

## Waarom het belangrijk is

Een ring buffer biedt voorspelbaar, toewijzingsvrij FIFO-gedrag, wat essentieel is in real-time en ingebedde systemen waar dynamische toewijzing te langzaam of riskant is.

De beperkte grootte fungeert ook als natuurlijke backpressure, waardoor snelle producers het geheugen niet uitputten.