C Academy · Lekcja

Przesunięcia

Przesunięcie w lewo i w prawo

Przesunięcia to bezpłatna lekcja C Academy na CoddyKit. To lekcja 2 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.

Przesuwanie bitów

Operatory przesunięcia przesuwają wszystkie bity liczby całkowitej w lewo lub w prawo o określoną liczbę pozycji.

Przesunięcie w lewo to <<, a przesunięcie w prawo to >>.

#include <stdio.h>

int main(void) {
    unsigned x = 1;
    printf("1 << 3 = %u\n", x << 3);
    return 0;
}

Przesunięcie w lewo mnoży

Przesunięcie w lewo o n pozycji mnoży wartość bez znaku przez 2 do potęgi n.

1 << 3 daje 8, a 5 << 1 daje 10.

#include <stdio.h>

int main(void) {
    printf("5 << 1 = %u\n", 5u << 1);
    printf("3 << 4 = %u\n", 3u << 4);
    return 0;
}

Przesunięcie w prawo dzieli

Przesunięcie w prawo o n pozycji dzieli wartość bez znaku przez 2 do potęgi n, odrzucając bity, które wypadają z prawej strony.

20 >> 2 daje 5.

#include <stdio.h>

int main(void) {
    printf("20 >> 2 = %u\n", 20u >> 2);
    printf("7 >> 1 = %u\n", 7u >> 1);
    return 0;
}

Potęgi dwójki

Przesunięcie liczby 1 w lewo to najszybszy sposób generowania potęg dwójki.

1 << n to n-ta potęga dwójki.

#include <stdio.h>

int main(void) {
    for (int n = 0; n < 6; n++) {
        printf("2^%d = %u\n", n, 1u << n);
    }
    return 0;
}

Wizualizacja przesunięcia

Wyświetlenie bitów przed przesunięciem i po nim pokazuje, jak przesuwa się ich układ.

#include <stdio.h>

void print_bits(unsigned char v) {
    for (int i = 7; i >= 0; i--) putchar((v >> i) & 1 ? '1' : '0');
    putchar('\n');
}

int main(void) {
    unsigned char v = 0b00000110;
    print_bits(v);
    print_bits(v << 2);
    return 0;
}

Odczytywanie bitu

Aby odczytać bit o numerze i, przesuń wartość w prawo o i pozycji i wykonaj maskowanie za pomocą 1.

Wynik to 0 albo 1.

#include <stdio.h>

int main(void) {
    unsigned v = 0b10110;
    for (int i = 0; i < 5; i++) {
        printf("bit %d = %u\n", i, (v >> i) & 1);
    }
    return 0;
}

Budowanie wartości bit po bicie

Można złożyć liczbę, przesuwając bity na właściwe pozycje i łącząc je operatorem OR.

#include <stdio.h>

int main(void) {
    unsigned v = 0;
    v |= (1u << 0);
    v |= (1u << 2);
    v |= (1u << 4);
    printf("v = %u\n", v);
    return 0;
}

Uwaga dotycząca przesuwania w prawo liczb ze znakiem

Przesuwanie w prawo ujemnej liczby całkowitej ze znakiem zależy od implementacji: bit znaku może zostać skopiowany.

Aby uzyskać przewidywalne operacje bitowe, należy preferować typy unsigned.

#include <stdio.h>

int main(void) {
    int s = -8;
    printf("-8 >> 1 = %d (implementation-defined)\n", s >> 1);
    unsigned u = 8;
    printf("8u >> 1 = %u\n", u >> 1);
    return 0;
}

Unikaj nadmiernego przesuwania

Przesunięcie o liczbę bitów większą lub równą szerokości typu jest niezdefiniowanym zachowaniem.

Przesunięcie wartości 32-bitowej o 32 bity lub więcej jest niedozwolone.

#include <stdio.h>
#include <limits.h>

int main(void) {
    printf("unsigned has %zu bits\n", sizeof(unsigned) * CHAR_BIT);
    printf("Safe shift 1u << 31 = %u\n", 1u << 31);
    return 0;
}

Łączenie przesunięcia i maski

Przesunięcie i maska razem pozwalają wyodrębnić pole złożone z kilku bitów. W tym przykładzie wyodrębniamy środkowe 4 bity z bajtu.

#include <stdio.h>

int main(void) {
    unsigned v = 0b11010110;
    unsigned field = (v >> 2) & 0b1111;
    printf("field = %u\n", field);
    return 0;
}

Szybkie mnożenie i dodawanie

Łączenie przesunięć pozwala szybko mnożyć przez stałe. Mnożenie przez 10 jest równoważne przesunięciu o 3 bity (razy 8) oraz przesunięciu o 1 bit (razy 2).

#include <stdio.h>

int main(void) {
    unsigned x = 7;
    unsigned times10 = (x << 3) + (x << 1);
    printf("7 * 10 = %u\n", times10);
    return 0;
}

Szybkie sprawdzenie

Sprawdź swoją wiedzę na temat przesunięć.

Podsumowanie

Dowiedziałeś się o operatorach przesunięcia:

<< przesuwa w lewo i mnoży przez potęgi liczby 2.
>> przesuwa w prawo i dzieli przez potęgi liczby 2.
(v >> i) & 1 wyodrębnia pojedynczy bit.
Używaj typu unsigned, aby uzyskać przewidywalne przesunięcia, i nigdy nie przesuwaj o szerokość typu lub więcej.

Często zadawane pytania

Czy lekcja „Przesunięcia” jest bezpłatna?

Tak — pełny tekst „Przesunięcia” 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 „Przesunięcia”?

Przesunięcie w lewo i w prawo Ć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 2 z 4.

Ile czasu zajmuje lekcja „Przesunięcia”?

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