O que é um circular buffer (ring buffer) e quando você usaria um?

Question

Accepted Answer

Um **circular buffer** é um array de tamanho fixo tratado como se suas extremidades fossem unidas em um anel. Dois índices — **head** (leitura) e **tail** (escrita) — avançam e envolvem usando aritmética de módulo, fornecendo uma fila FIFO O(1) **sem alocação** após a criação.

## Como o envolvimento funciona

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

## Código

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

| Operação | Tempo |
|---|---|
| enqueue / dequeue | O(1) |
| espaço | O(n) fixo |

## Quando usar

- **Buffers de streaming / áudio / vídeo** — limitado, throughput constante.
- **Pipelines produtor–consumidor** com backpressure.
- **Registrar os últimos N eventos** (sobrescrever os mais antigos).

## Por que isso importa

Um buffer de anel fornece comportamento FIFO previsível e sem alocação, que é essencial em sistemas em tempo real e embarcados onde a alocação dinâmica é muito lenta ou arriscada.

Seu tamanho limitado também atua como backpressure natural, impedindo que produtores rápidos esgottem a memória.