Che cos'è un buffer circolare (ring buffer) e quando lo useresti?

Question

Accepted Answer

Un **buffer circolare** è un array di dimensione fissa trattato come se i suoi estremi fossero uniti in un anello. Due indici — **head** (lettura) e **tail** (scrittura) — avanzano e si avvolgono usando l'aritmetica modulo, fornendo una coda FIFO O(1) con **nessuna allocazione** dopo la creazione.

## Come funziona l'avvolgimento

```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
```

| Operazione | Tempo |
|---|---|
| enqueue / dequeue | O(1) |
| spazio | O(n) fisso |

## Quando usarlo

- **Buffer di streaming / audio / video** — limitati, con throughput costante.
- **Pipeline produttore–consumatore** con backpressure.
- **Logging degli ultimi N eventi** (sovrascrivere i più vecchi).

## Perché è importante

Un ring buffer fornisce un comportamento FIFO prevedibile e senza allocazione, essenziale nei sistemi real-time e embedded dove l'allocazione dinamica è troppo lenta o rischiosa.

La sua dimensione limitata agisce anche come backpressure naturale, prevenendo ai produttori veloci di esaurire la memoria.