---
title: "@bitReverse em Zig — Referência e Exemplos"
url: "https://ziglang.com.br/builtins/@bitreverse-em-zig-refer%C3%AAncia-e-exemplos/"
markdown_url: "https://ziglang.com.br/builtins/@bitreverse-em-zig-refer%C3%AAncia-e-exemplos.MD"
description: "Referência completa do @bitReverse em Zig. Inverta a ordem dos bits de um inteiro. Útil para FFT, CRC e protocolos seriais. Exemplos pt-BR."
date: "2026-02-21"
author: "Zig Brasil"
---

# @bitReverse em Zig — Referência e Exemplos

Referência completa do @bitReverse em Zig. Inverta a ordem dos bits de um inteiro. Útil para FFT, CRC e protocolos seriais. Exemplos pt-BR.


# @bitReverse em Zig

O `@bitReverse` inverte a **ordem de todos os bits** de um valor inteiro — o bit mais significativo se torna o menos significativo e vice-versa. Diferente de `@byteSwap` que inverte bytes, `@bitReverse` inverte cada bit individual. Usado em FFT (Fast Fourier Transform), CRC, protocolos seriais e algoritmos de hashing.

## Sintaxe

```zig
@bitReverse(value: T) T
```

## Parâmetros

- **value** (`T`): Valor inteiro cujos bits serão invertidos.

## Valor de retorno

Retorna `T` — o valor com a ordem dos bits completamente invertida.

## Exemplos práticos

### Exemplo 1: Inversão básica de bits

```zig
const std = @import("std");

pub fn main() void {
    const a: u8 = 0b10110001;
    const b = @bitReverse(a);

    std.debug.print("Original:  0b{b:0>8}\n", .{a}); // 0b10110001
    std.debug.print("Invertido: 0b{b:0>8}\n", .{b}); // 0b10001101

    // Para u16
    const c: u16 = 0b1000000000000000;
    const d = @bitReverse(c);
    std.debug.print("u16: 0b{b:0>16} -> 0b{b:0>16}\n", .{ c, d });
    // 0b1000000000000000 -> 0b0000000000000001
}
```

### Exemplo 2: Bit-reversal permutation (para FFT)

```zig
const std = @import("std");

fn bitReversalPermutation(comptime N: usize, dados: *[N]f32) void {
    const bits = @ctz(@as(usize, N)); // log2(N)

    for (0..N) |i| {
        const j = @bitReverse(@as(std.meta.Int(.unsigned, bits), @intCast(i)));
        if (i < j) {
            const temp = dados[i];
            dados[i] = dados[j];
            dados[j] = temp;
        }
    }
}

pub fn main() void {
    var dados = [_]f32{ 0, 1, 2, 3, 4, 5, 6, 7 };
    bitReversalPermutation(8, &dados);

    std.debug.print("Permutação: ", .{});
    for (dados) |v| {
        std.debug.print("{d:.0} ", .{v});
    }
    std.debug.print("\n", .{}); // 0 4 2 6 1 5 3 7
}
```

### Exemplo 3: CRC com bit reversal

```zig
const std = @import("std");

fn refletir8(valor: u8) u8 {
    return @bitReverse(valor);
}

pub fn main() void {
    // Em CRC, dados são frequentemente refletidos
    const byte: u8 = 0b11010010;
    const refletido = refletir8(byte);

    std.debug.print("Original:  0b{b:0>8}\n", .{byte});
    std.debug.print("Refletido: 0b{b:0>8}\n", .{refletido});
}
```

## Casos de uso comuns

1. **FFT**: Bit-reversal permutation é passo fundamental da FFT.
2. **CRC**: Alguns algoritmos CRC exigem reflexão de bits.
3. **Protocolos seriais**: LSB-first para MSB-first e vice-versa.
4. **Criptografia**: Transformações de bits em cifras.

## @bitReverse vs @byteSwap

É fácil confundir os dois. A diferença é clara com um exemplo:

```zig
const valor: u32 = 0xABCD1234;

// @byteSwap inverte a ordem dos BYTES
// 0xABCD1234 -> 0x3412CDAB
const bytes_invertidos = @byteSwap(valor);

// @bitReverse inverte a ordem de todos os BITS individuais
// Cada bit é refletido em torno do centro
const bits_invertidos = @bitReverse(valor);
```

Use `@byteSwap` para converter endianness. Use `@bitReverse` quando precisar de inversão bit-a-bit (FFT, CRC, protocolos seriais).

## Equivalente em C

Em C não existe builtin portável para inversão de bits. A implementação manual é verbosa:

```c
uint8_t bit_reverse_u8(uint8_t x) {
    x = ((x & 0xF0) >> 4) | ((x & 0x0F) << 4);
    x = ((x & 0xCC) >> 2) | ((x & 0x33) << 2);
    x = ((x & 0xAA) >> 1) | ((x & 0x55) << 1);
    return x;
}
```

GCC e Clang oferecem `__builtin_bitreverse8/16/32/64` como extensão não-portável. O Zig mapeia `@bitReverse` diretamente para essas instruções quando disponíveis.

## Considerações de performance

O compilador Zig gera código otimizado para `@bitReverse`. Em arquiteturas que têm instrução nativa de bit reversal (como ARM com RBIT), o compilador emite diretamente essa instrução. Em x86, onde não há instrução nativa, o compilador usa uma sequência eficiente de shifts e masks — geralmente mais eficiente que qualquer implementação manual.

## Tipos suportados

`@bitReverse` funciona com **qualquer tipo inteiro**, incluindo tipos não-padrão:

```zig
const a = @bitReverse(@as(u3, 0b101));  // 0b101 -> 0b101 (simétrico)
const b = @bitReverse(@as(u4, 0b1001)); // 0b1001 -> 0b1001 (simétrico)
const c = @bitReverse(@as(u4, 0b1100)); // 0b1100 -> 0b0011
```

## Perguntas Frequentes

**`@bitReverse` de zero retorna zero?**

Sim. Todos os bits zero invertidos continuam sendo zero. Igualmente, `@bitReverse` do valor máximo (todos bits 1) retorna o valor máximo.

**Qual a diferença entre @bitReverse e NOT bit-a-bit?**

`NOT` (operador `~`) inverte o valor de cada bit (0→1, 1→0). `@bitReverse` mantém os valores dos bits mas inverte a posição deles (bit 0 vai para a posição N-1, bit 1 para N-2, etc.).

**@bitReverse funciona com inteiros signed?**

Sim. O builtin trata os bits como representação binária bruta, independente de sinal. O resultado é o valor signed com os bits na ordem inversa.

## Builtins relacionados

- [@byteSwap](/builtins/byte-swap/) — Inverter ordem dos bytes (não bits)
- [@clz](/builtins/clz/) — Contar zeros à esquerda
- [@ctz](/builtins/ctz/) — Contar zeros à direita
- [@popCount](/builtins/pop-count/) — Contar bits em 1

## Tutoriais relacionados

- [Operações Bit a Bit em Zig](/tutoriais/bitwise-zig/)
- [Sistema de Tipos do Zig](/tutoriais/tipos/)
- [Introdução ao Zig](/tutoriais/introducao-ao-zig/)