Qu'est-ce qu'un buffer circulaire (ring buffer) et quand l'utiliserait-on ?

Question

Accepted Answer

Un **circular buffer** est un tableau de taille fixe traité comme si ses extrémités étaient jointes en anneau. Deux indices — **head** (lecture) et **tail** (écriture) — avancent et se réajustent en utilisant l'arithmétique modulo, donnant une file FIFO en O(1) **sans allocation** après sa création.

## Comment l'enroulement fonctionne

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

| Opération | Temps |
|---|---|
| enqueue / dequeue | O(1) |
| espace | O(n) fixe |

## Quand l'utiliser

- **Buffers de streaming / audio / vidéo** — débit borné et constant.
- **Pipelines producteur–consommateur** avec contre-pression.
- **Enregistrement des N derniers événements** (remplacement des plus anciens).

## Pourquoi c'est important

Un ring buffer fournit un comportement FIFO prévisible et sans allocation, ce qui est essentiel dans les systèmes temps réel et embarqués où l'allocation dynamique est trop lente ou risquée.

Sa taille bornée agit aussi comme une contre-pression naturelle, empêchant les producteurs rapides d'épuiser la mémoire.