Dlaczego C nie ma literałów binarnych?

Question

ja często chcąc mogłem zrobić coś takiego w C:

val1 &= 0b00001111; //clear high nibble 
val2 |= 0b01000000; //set bit 7 
val3 &= ~0b00010000; //clear bit 5 

Mając tę ​​składnię wydaje się niezwykle użytecznym dodatkiem do C bez wad, że mogę myśleć, i wydaje się, że naturalną rzeczą dla język niskiego poziomu, w którym bit-twiddling jest dość powszechny.

Edycja: Widzę kilka innych wspaniałych alternatyw, ale wszystkie one rozpadać, gdy jest bardziej skomplikowana maska. Na przykład, jeśli reg jest rejestrem, który kontroluje szpilki I/O mikrokontrolera, i chcę ustawić styki 2, 3 i 7 na wysokim poziomie w tym samym czasie mógłbym napisać reg = 0x46; ale musiałem spędzić 10 sekund o tym myśleć (i prawdopodobnie będę musiał spędzić 10 sekund ponownie za każdym razem, gdy czytam ten kod po tym, jak nie patrzę na niego przez dzień lub dwa) lub mogę napisać reg = (1 << 1) | (1 << 2) | (1 << 6);, ale osobiście uważam, że jest to o wiele mniej jasne niż pisanie `reg = 0b01000110 ; " Mogę się zgodzić, że nie skaluje się to jednak znacznie poza architektury 8-bitowe lub 16-bitowe. Nie, żebym kiedykolwiek musiał zrobić maskę 32-bitową.

Answer 1

To właśnie pchnął hexadecimal być ... szesnastkowo. Podstawowym zastosowaniem zapisu szesnastkowego jest "... " przyjazna dla człowieka reprezentacja wartości kodowanych binarnie w komputerach i cyfrowej elektronice ... ". byłoby to w następujący sposób:

val1 |= 0xF; 
val2 &= 0x40; 
val3 |= ~0x10; 

szesnastkowym:

1. jeden cyfrowy heks może stanowić dziobanie (4 bity lub pół ósemkowy).
2. Dwie cyfry szesnastkowe mogą reprezentować bajt (8 bitów).
3. Sześciokąt jest znacznie bardziej zwarty, gdy skaluje się do większych masek.

Z pewną praktyką konwersja między szesnastkową a binarną stanie się znacznie bardziej naturalna. Spróbuj zapisywać konwersje ręcznie i nie używaj internetowego konwertera notacji bin/hex - wtedy za kilka dni stanie się to naturalne (i szybsze w rezultacie).

marginesie: Nawet literały binarne nie są standardowym C, jeśli skompilować z GCC jest możliwe użycie literałów binarnych, powinny być poprzedzone „0B” lub „0B”. Więcej informacji można znaleźć w oficjalnej dokumentacji here. Przykład:

int b1 = 0b1001; // => 9 
int b2 = 0B1001; // => 9 

Answer 2

Według Rationale for International Standard - Programming Languages C §6.4.4.1 Integer stałych

Propozycja dodać stałych binarnych został odrzucony ze względu na brak precedensu i niewystarczającej użyteczności.

To nie jest w standardzie C, ale GCC obsługuje go jako rozszerzenie poprzedzony 0b lub 0B:

i = 0b101010; 

Zobacz here o szczegóły.

Answer 3

Wszystkie Twoje przykłady można pisanych jeszcze wyraźniej:

val1 &= (1 << 4) - 1; //clear high nibble 
val2 |= (1 << 6); //set bit 6 
val3 &=~(1 << 3); //clear bit 3 

(Brałem wolność ustalające komentarzy liczyć od zera, jak Nature przeznaczone.)

Twój kompilator spasuje te stałe, więc nie ma kary za wydajność, aby je zapisać w ten sposób. I są one łatwiejsze do odczytania niż wersje 0b....

Answer 4

Myślę, że czytelność jest podstawową sprawą. Chociaż na niskim poziomie, to ludzie czytają i utrzymują twój kod, a nie maszynę.

Czy łatwo jest ci się domyślić, że przez pomyłkę wpiszesz 0b1000000000000000000000000000000(0x40000000), gdzie naprawdę masz na myśli 0b10000000000000000000000000000000(0x80000000)?

Answer 5

Jeśli nie potrzeba rzeczywistej dosłowne, można zrobić coś takiego:

#define B_(x) strtoull(#x, 0, 2) 

unsigned char low_nibble = B_(00001111); 
unsigned char bit_7 = B_(01000000); 
unsigned char bit_5 = B_(00010000); 

val1 |= low_nibble; 
val2 &= bit_7; 
val3 |= ~bit_5; 

Answer 6

„Na przykład, jeśli reg jest rejestrem, który kontroluje szpilki I/O mikrokontrolera”

Nie mogę oprzeć się wrażeniu, że to zły przykład. Bity w rejestrach kontrolnych mają określone funkcje (podobnie jak wszelkie urządzenia podłączone do poszczególnych bitów IO).

Znacznie rozsądniej byłoby podać stałe symboliczne dla wzorców bitów w pliku nagłówkowym, zamiast opracowywać kod binarny w kodzie. Konwersja binarna na szesnastkową lub ósemkową jest banalna, pamiętając, co się stanie, gdy napiszesz 01000110 do rejestru IO, a nie, szczególnie, jeśli nie masz pod ręką arkusza danych lub schematu obwodu.

W ten sposób nie tylko uratujesz te 10 sekund, próbując wypracować kod binarny, ale może nieco dłużej próbując ustalić, co robi!