dla wielkoÅ›ci typu unsigned zwolnione bity zawsze s¸ wypeÅ‚nia-
a
Bitowe operatory
ne zerami. Natomiast dla wielkości ze znakiem spowoduje to
na pewnych maszynach wypełnienie tych miejsc bitem znaku
logiczne
(przesuni¸ arytmetyczne), a na innych zerami (przesuni¸
ecie ecie
logiczne).
Uwaga: Nie można ich używać do danych typu float lub double.
Dopełnienie jedynkowe
& bitowa koniunkcja
~
| bitowa alternatywa
Zamienia każdy bit 1 na 0 i odwrotnie. Typowe użycie:
^ bitowa różnica symetryczna
y = x&~077;
« przesuni¸ w lewo
ecie
zasÅ‚ania si¸ zerami ostatnie sześć bitów zmiennej x.
e
przesuni¸ w prawo
ecie
Uwaga: Ta konstrukcja nie zależy od maszyny, pod-
~ uzupełnienie jedynkowe
czas gdy:
y = x&0177700;
Koniunkcja bitowa &
zakłada 16-bitowe słowo maszynowe.
& stosuje si¸ cz¸ do  zasÅ‚aniania pewnego zbioru bitów,
e esto
np.
Przykład:
c = n&0177;
s¸ zerowane wszystkie oprócz siedmiu najniższych bitów wartoÅ›ci
a
zmiennej n.
/* getbits: daj n bitow x od pozycji p
Zerowa pozycja bitu jest prawy koniec x;
Różnice mi¸
edzy & i &&
n, p sa sensownymi wielkosciami calkowitymi
*/
unsigned getbits(unsigned x, int p, int n)
Np. Jesli x=1, y=2 to
{
return (x >> (p+1-n)) & ~(~0 << n);
x & y ma wartosc 0
}
x && y 1
Operacje bitowe na
Bitowy operator alter-
znakach
natywy |
Kody ASCII
Bit 7 6 5 4 3 2 1 0
Używany do  ustawiania bitów. Np.
0 - cyfry 0 - duże 0 - a-o
litery
x = x|MASK;
1 - litery 1 - cyfry cyfry
ustawia 1 na tych bitach w zmiennej x, które wMASK s¸ równe
a
/małe /p-z
1.
litery
Bitowa różnica syme-
char toupper(char c)
tryczna ^
/* Funkcja zamienia male litery na duze */
{
Ustawia jedynk¸ na każdej pozycji bitowej tam, gdzie bity w
e
char maska=223; /* 223 - 11011111 */
obu argumentach s¸ różne, a zero tam, gdzie sa takie same. Np.
a ¸
return c & maska;
}
x = 011^022;
daje w rezultacie wartość 0.
char tolower(char c)
/* Funkcja zamienia duze litery na male */
Operatory przesuni¸
ecia
{
return c | 32; /* 32 - 00100000 */
« oraz
}
SÅ‚uż¸ do przesuwania argumentu stoj¸ po lewej stronie
a acego
operatora o liczb¸ pozycji okreÅ›lon¸ przez argument stoj¸ po
e a acy
prawej stronie. Np.
char swapcase{char c)
y = x<<2;
/* Zamiana duzych liter na male i odwrotnie */
przesuwa x w lewo o dwie pozycje, zwolnione bity wypeÅ‚nia si¸
e
{
zerami (operacja równoważna mnożeniu przez 4.
return c ^ 32;
}
y = x>>2;
int razy10(int n)
Priorytety i kolejność
/* Mnozenie liczby calkowitej przez 10
przy pomocy operatorow przesuniecia */
obliczeń
{
int m,p;
Priorytety i łaczność operatorów
¸
m=n<<1;
Operatory A
¸
acz-
p=m<<2;
ność
return m+p;
() [] -> . LR
}
! - ++ -- + - * & (type) sizeof RL
* / % LR
Operatory i wyrażenia
+ - LR
przypisania op=
<< >> LR
i=i+3; jest równoważne i+=3;
< <= > >= LR
op jest jednym z operator\ ow:
== != LR
+ - * / % << >> & ^ |
& LR
UWAGA: Jezeli wyr1 i wyr2 sa wyrazeniami, to
^ LR
wyr1 op= wyr2; jest rownowazne z
| LR
wyr1=(wyr1) op (wyr2);
&& LR
Zatem przypisanie
|| LR
x *= y+1; jest odpowiednikiem x=x*(y+1);
?: LR
= += -= *= /= %= ^= |= <<= >>= RL
Przykład:
, LR
/* Zlicz bity argumentu o wartosci 1 */
Jednoargumentowe operatory +, -, * oraz & maja wyższy
¸
int bitcount(unsigned x)
priorytet, niż ich odpowiedniki dwuargumentowe.
{
Lewostrona łaczność operatora oznacza, że jeśli na tym sa-
¸
int b;
mym poziomie wystepuje kilka operatorów, to najpierw jest wy-
¸
for (b=0; x!=0; x >> 1)
konywany operator lewy.
if (x & 01)
b++;
return b;
Wjezyku C nie okreÅ›la si¸ kolejnoÅ›ci obliczania argumentów
¸ e
}
operatora. Wyjatki, to:
¸
&&, ||, ?: oraz ,
Np. w instrukcji x=f()+g(); f może być
wykonana przed g lub odwrotnie.
Wyrażenia warunkowe
Nie jest określona kolejność obliczania wartości argumentów
Instrukcja realizuj¸ funkcj¸ z=max(a,b)
aca e
funkcji. Instrukcja
if (a>b)
printf ("%d %d\n", ++n, power(2,n));
z=a;
może generowć różne wyniki w zależności od kompilatora.
Możliwe s¸ również inne efekty  uboczne (generowane przez
a
else
wywołania funkcji, zagnieżdżone instrukcje przypisania oraz ope-
ratory zwi¸ i zmniejszania), np.
ekszania
z=b;
a[i]=i++;
zależy od kolejności aktualizacji wartości zmiennych
jest rownowazna z=(a>b) ? a:b;
bior¸ udziaÅ‚ w obliczeniach.
acych
albo z= a>b ? a:b;
Konkluzja: Pisanie programów zależnych od kolejności wyko-
nania obliczeń należy do złej praktyki programowania w każdym
j¸
ezyku.
Priorytet operatora ?: jest bardzo niski.
Wyrażenie warunkowe cz¸ wpÅ‚ywa na zwi¸ programu.
esto ezłość
Np.
Sterowanie
1)
for (i=0; iprintf("%6d%c", a[i],
(i%10 == 9 || i== n-1) ?  \n :  );
Instrukcje i bloki
2)
printf("Masz %d czes%s.\n",n, n==1 ? "c":"ci");
Wyrażenie staje si¸ instrukcj¸ po zakoÅ„czeniu Å›rednikiem, np.
e a
x=0; /* szukanie x metoda bisekcji wsrod
i++; v[0]<=v[1]<=...<=v[n-1] */
printf{"Uwaga!\n"); int binsearch(int x, int v[], int n)
{
int low=0, high, mid;
high=n-1;
Nawiasy klamrowe { i } s¸ używane do tworzenia
a
while (low <= high){
bloku. (Zmienne można zadeklarować wewn¸ każdego bloku.)
atrz
mid=(low+high)/2;
Po nawiasie zamykaacym blok nie może wyst¸ Å›rednik.
¸ epować
if (xhigh=mid-1;
else if (x>v[mid])
Instrukcja if-else
low=mid+1;
else /* znaleziono */
return mid;
}
if (wyrazenie)
return -1; /* Nie znaleziono */
instrukcja1
}
else
instrukcja2
Cz¸ else można pominać.
eść ¸
Najcz¸ pisze si¸
eściej e
if (wyrazenie)
zamiast
if (wyrazenie != 0)
Każda cz¸ else jest przyporz¸
eść adkowana najbliższej z po-
przednich instrukcji if nie zawierajacej cz¸ else, np.
¸ eÅ›ci
if (n>0)
if (a>b)
z=a;
else
z=b;
Dwuznaczność ta jest szczególnie szkodliwa w takich sytu-
acjach, jak
if (n>0)
for (i=0; iif (s[i] > 0) {
printf("...");
return i;
}
else /* Zle */
printf("Blad -- n jest ujemne);
Wci¸ wyraz
nie pokazuje, o co chodzi programiście, ale kom-
ecie
pilator przyporz¸ else wewnetrznej funkcji if.
adkuje ¸
konstrukcja else-if
if (wyrazenie)
instrukcja
else if (wyrazenie)
instrukcja
else if (wyrazenie)
instrukcja
Przykład: