C Academy · Lezione

Trucchi pratici con i bit

Tecniche comuni

Trucchi pratici con i bit è una lezione C Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento C Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso C Academy include 4 lezioni in totale.

Trucchi utili sui bit

Una volta compresi gli operatori bitwise, diventano disponibili numerosi trucchi compatti. Sono veloci e ricorrono spesso nel codice reale.

Esaminiamo quelli più comuni.

#include <stdio.h>

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

Pari o dispari

Il bit meno significativo indica la parità. x & 1 vale 1 per i numeri dispari e 0 per quelli pari.

#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;
}

Verificare una potenza di due

Un numero positivo è una potenza di due se ha esattamente un bit impostato. L'espressione x & (x - 1) vale 0 solo in questo 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;
}

Azzerare il bit impostato meno significativo

x & (x - 1) azzera il bit impostato meno significativo. Questo è il principio alla base del conteggio rapido dei bit impostati.

#include <stdio.h>

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

Isolare il bit impostato meno significativo

x & (-x) isola il bit impostato meno significativo, lasciando attivo solo quel singolo bit.

Questa tecnica si basa sulla rappresentazione in complemento a due.

#include <stdio.h>

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

Contare i bit impostati

L'azzeramento ripetuto del bit impostato meno significativo consente di contare quanti bit sono impostati, con un numero di passaggi pari al numero di bit impostati.

#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;
}

Scambiare senza una variabile temporanea

Lo scambio tramite XOR scambia due interi senza utilizzare memoria aggiuntiva.

#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;
}

Arrotondare alla potenza di due superiore

È possibile arrotondare un valore unsigned alla potenza di due successiva propagando verso il basso il bit più significativo e aggiungendo quindi 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;
}

Verificare se i bit differiscono

Due valori hanno bit diversi esattamente nelle posizioni in cui a ^ b contiene bit impostati. Il conteggio di questi bit fornisce la distanza di 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;
}

Valore assoluto senza branch

Utilizzando il bit del segno, è possibile calcolare il valore assoluto senza un if. La maschera contiene tutti 1 per i numeri negativi e tutti 0 per quelli non negativi.

#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;
}

Impostare un bit tramite indice

Combini shift e OR per impostare una posizione di bit arbitraria calcolata durante l'esecuzione.

#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 rapida

Verifichi la Sua conoscenza dei trucchi sui bit.

Riepilogo

Ha imparato alcuni trucchi pratici sui bit:

x & 1 verifica se un numero è pari o dispari.
x & (x - 1) azzera il bit impostato meno significativo e rileva le potenze di due.
x & (-x) isola il bit impostato meno significativo.
Popcount, scambio tramite XOR, distanza di Hamming e valore assoluto senza branch.

Domande Frequenti

La lezione «Trucchi pratici con i bit» è gratuita?

Sì — il testo completo di «Trucchi pratici con i bit» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso C Academy, passa a CoddyKit PRO. Il corso C Academy include 4 lezioni in totale.

Cosa imparerò in «Trucchi pratici con i bit»?

Tecniche comuni Eserciti C Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare C Academy?

Non è richiesta alcuna esperienza precedente. C Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Trucchi pratici con i bit»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione C Academy?

Sì. Ogni lezione C Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a C Academy