C Academy · Aula

Truques práticos com bits

Técnicas comuns.

Truques práticos com bits é uma aula grátis de C Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C Academy inclui 4 aulas no total.

Truques úteis com bits

Depois que você entende os operadores bit a bit, passa a ter acesso a um conjunto de truques compactos. Eles são rápidos e aparecem com frequência em código real.

Vamos analisar os mais comuns.

#include <stdio.h>

int main(void) {
    unsigned x = 6;
    printf("x & 1 = %u (odd if 1)\n", x & 1);
    return 0;
}

Par ou ímpar

O bit de menor ordem indica a paridade. x & 1 é 1 para números ímpares e 0 para números pares.

#include <stdio.h>

int main(void) {
    for (unsigned x = 0; x < 5; x++) {
        printf("%u is %s\n", x, (x & 1) ? "odd" : "even");
    }
    return 0;
}

Verificando potências de dois

Um número positivo é uma potência de dois quando tem exatamente um bit definido. A expressão x & (x - 1) é 0 somente nesse caso.

#include <stdio.h>

int is_pow2(unsigned x) {
    return x != 0 && (x & (x - 1)) == 0;
}

int main(void) {
    printf("%d %d %d\n", is_pow2(16), is_pow2(18), is_pow2(1));
    return 0;
}

Limpando o bit definido de menor ordem

x & (x - 1) limpa o bit definido de menor ordem. Essa é a base da contagem rápida de bits definidos.

#include <stdio.h>

int main(void) {
    unsigned x = 0b10110;
    printf("before: %u\n", x);
    printf("after:  %u\n", x & (x - 1));
    return 0;
}

Isolando o bit definido de menor ordem

x & (-x) isola o bit definido de menor ordem, deixando somente esse bit ativado.

Isso depende da representação em complemento de dois.

#include <stdio.h>

int main(void) {
    unsigned x = 0b10110;
    printf("lowest set bit = %u\n", x & (-x));
    return 0;
}

Contando bits definidos

Limpar repetidamente o bit definido de menor ordem conta quantos bits estão definidos, usando tantas etapas quantos forem os bits definidos.

#include <stdio.h>

int popcount(unsigned x) {
    int n = 0;
    while (x) { x &= (x - 1); n++; }
    return n;
}

int main(void) {
    printf("%d\n", popcount(255));
    printf("%d\n", popcount(0b1010));
    return 0;
}

Trocando sem uma variável temporária

A troca com XOR troca dois inteiros sem usar armazenamento extra.

#include <stdio.h>

int main(void) {
    int a = 3, b = 8;
    a ^= b; b ^= a; a ^= b;
    printf("a=%d b=%d\n", a, b);
    return 0;
}

Arredondando para cima até uma potência de dois

Você pode arredondar um valor sem sinal para a próxima potência de dois espalhando o bit mais significativo para baixo e depois adicionando 1.

#include <stdio.h>

unsigned next_pow2(unsigned v) {
    v--;
    v |= v >> 1; v |= v >> 2; v |= v >> 4;
    v |= v >> 8; v |= v >> 16;
    return v + 1;
}

int main(void) {
    printf("%u\n", next_pow2(17));
    printf("%u\n", next_pow2(100));
    return 0;
}

Verificando se os bits diferem

Dois valores têm bits diferentes exatamente nas posições em que a ^ b tem bits definidos. Contá-los fornece a distância de Hamming.

#include <stdio.h>

int main(void) {
    unsigned a = 0b1101, b = 0b1011;
    unsigned diff = a ^ b;
    int count = 0;
    while (diff) { diff &= diff - 1; count++; }
    printf("hamming distance = %d\n", count);
    return 0;
}

Valor absoluto sem ramificação

Usando o bit de sinal, você pode calcular um valor absoluto sem um if. A máscara é formada por todos os bits 1 para números negativos e por todos os bits 0 para números não negativos.

#include <stdio.h>

int main(void) {
    int x = -42;
    int mask = x >> 31;
    int abs = (x + mask) ^ mask;
    printf("abs = %d\n", abs);
    return 0;
}

Definindo um bit por índice

Combine deslocamento e OR para definir uma posição de bit arbitrária calculada em tempo de execução.

#include <stdio.h>

int main(void) {
    unsigned v = 0;
    int positions[] = {1, 3, 5};
    for (int i = 0; i < 3; i++) {
        v |= (1u << positions[i]);
    }
    printf("v = %u\n", v);
    return 0;
}

Verificação rápida

Teste seus conhecimentos sobre truques com bits.

Recapitulação

Você aprendeu truques práticos com bits:

x & 1 testa se um número é par ou ímpar.
x & (x - 1) limpa o bit definido de menor ordem e detecta potências de dois.
x & (-x) isola o bit definido de menor ordem.
Contagem de bits, troca com XOR, distância de Hamming e valor absoluto sem ramificações.

Perguntas Frequentes

A aula “Truques práticos com bits” é grátis?

Sim — o texto completo de “Truques práticos com bits” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C Academy, atualize para CoddyKit PRO. O curso de C Academy inclui 4 aulas no total.

O que vou aprender em “Truques práticos com bits”?

Técnicas comuns. Você pratica C Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C Academy?

Nenhuma experiência prévia é necessária. C Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Truques práticos com bits”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C Academy?

Sim. Cada aula de C Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para C Academy