C Academy · Lekcja

Praktyczne sztuczki bitowe

Typowe techniki

Praktyczne sztuczki bitowe to bezpłatna lekcja C Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C Academy zawiera 4 lekcji w sumie.

Przydatne sztuczki bitowe

Gdy zrozumiesz operatory bitowe, zyskasz dostęp do zestawu zwięzłych sztuczek. Są szybkie i często pojawiają się w rzeczywistym kodzie.

Omówmy najczęściej stosowane z nich.

#include <stdio.h>

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

Parzystość i nieparzystość

Najniższy bit wskazuje parzystość. x & 1 ma wartość 1 dla liczb nieparzystych i 0 dla liczb parzystych.

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

Sprawdzanie potęgi liczby 2

Dodatnia liczba jest potęgą liczby 2, jeśli ma ustawiony dokładnie jeden bit. Wyrażenie x & (x - 1) ma wartość 0 tylko w takim przypadku.

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

Zerowanie najniższego ustawionego bitu

x & (x - 1) zeruje najniższy ustawiony bit. Na tej operacji opiera się szybkie zliczanie ustawionych bitów.

#include <stdio.h>

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

Wyodrębnianie najniższego ustawionego bitu

x & (-x) wyodrębnia najniższy ustawiony bit, pozostawiając włączony tylko ten jeden bit.

Wykorzystuje to reprezentację w kodzie uzupełnień do dwóch.

#include <stdio.h>

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

Zliczanie ustawionych bitów

Wielokrotne zerowanie najniższego ustawionego bitu pozwala zliczyć ustawione bity, wykonując tyle kroków, ile jest ustawionych bitów.

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

Zamiana bez zmiennej tymczasowej

Zamiana XOR wymienia dwie liczby całkowite bez użycia dodatkowej pamięci.

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

Zaokrąglanie w górę do potęgi liczby 2

Możesz zaokrąglić wartość bez znaku w górę do najbliższej potęgi liczby 2, rozprzestrzeniając najwyższy bit w dół, a następnie dodając 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;
}

Sprawdzanie różnic bitów

Dwie wartości różnią się dokładnie w tych bitach, w których a ^ b ma ustawione bity. Ich zliczenie daje odległość Hamminga.

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

Wartość bezwzględna bez rozgałęzienia

Za pomocą bitu znaku można obliczyć wartość bezwzględną bez użycia instrukcji if. Maska składa się z samych jedynek dla liczb ujemnych i z samych zer dla liczb nieujemnych.

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

Ustawianie bitu według indeksu

Połącz przesunięcie i OR, aby ustawić dowolną pozycję bitu obliczoną w czasie działania programu.

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

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat sztuczek bitowych.

Podsumowanie

Poznałeś praktyczne sztuczki bitowe:

x & 1 sprawdza parzystość lub nieparzystość.
x & (x - 1) zeruje najniższy ustawiony bit i wykrywa potęgi liczby 2.
x & (-x) wyodrębnia najniższy ustawiony bit.
Popcount, zamiana XOR, odległość Hamminga i bezrozgałęzieniowa wartość bezwzględna.

Często zadawane pytania

Czy lekcja „Praktyczne sztuczki bitowe” jest bezpłatna?

Tak — pełny tekst „Praktyczne sztuczki bitowe” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C Academy, przejdź na CoddyKit PRO. Kurs C Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Praktyczne sztuczki bitowe”?

Typowe techniki Ćwiczysz C Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć C Academy?

Nie wymagamy żadnego doświadczenia. C Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Praktyczne sztuczki bitowe”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji C Academy?

Tak. Każda lekcja C Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do C Academy