Bitműveletek. Az értékadas és a típuskonverzió. Precedencia és asszociativitas.

Bitműveletek. Az értékadás és a típuskonverzió. Precedencia és asszociativitás.

Bitenkénti logikai operátorok

A bitenkénti operátorok jelölésmódja és értelmezése a következô :

& : bitenkénti ÉS
¦ : bitenkénti VAGY
^ : bitenkénti KIZĹRÓ VAGY
<<: bitléptetés balra (SHIFT LEFT)
>>: bitléptetés jobbra (SHIFT RIGHT)
~ : egyes komplemens képzés ( egyoperandusú ! )

Az operátorok működésének magyarázata a következô :

Az & kétoperandusú művelet eredménye csak akkor 1, ha mindkét operandus ugyan­azon bitpozíciójában elhelyezkedô bitek értéke egyaránt 1. Minden más eset­ben az eredmény 0. Az & 737d37h ; operátort valamely bithalmaz maszkolásá­ra használ­hatjuk.

Az ¦ kétoperandusú művelet eredménye csak akkor nulla, ha mindkét operan­dus ugyan­azon bitpozíciójában elhelyezkedô bitek értéke egyaránt 0. Minden más esetben az eredmény 1. A ¦ operátort bit(ek) 1-re állítására használhat­juk.

Az & ill. ¦ nem tévesztendô össze a && ill. ¦¦ operátorokkal. Például : ha x érté­ke 2 és y értéke 4, akkor x & y = 0 ill. x && y = 1 : x = 00000010 | = 2
y = 00000100 | = 4
----- ----- ------------
x&y = 00000000 | = 0

ill. x && y értéke nyilván 1 lesz mert x is igaz és y is igaz. ( Értékük nullától különbözô ! )

A ^ kétoperandusú művelet eredménye csak akkor 1, ha mindkét operandus ugyan­azon bitpozíciójában elhelyezkedô bitek értéke egymással ellentétes. Ellenkezô esetben az eredmény 0.

A << kétoperandusú művelet során a baloldali operandus minden bitje, annyi­szor moz­­dul el balra 1 pozicióval, ahányszor azt a jobb oldali operandussal megadjuk.

A >> kétoperandusú művelet során a baloldali operandus minden bitje, annyi­szor moz­­dul el jobbra 1 pozicióval, ahányszor azt a jobb oldali operandus­sal megadjuk.

A ~ egyoperandusú művelet a mögötte álló operátor 1-es komplemensét állít­ja elô, azaz minden 1-es bitet nullára állít és viszont.

Fontos :   A bitműveletek kizárólag egész jellegü mennyiségekre értelme­zet­tek (példánkban a char típusra), float és double típusú válto­zók­­ra nem al­kal­maz­hatók !

Típuskonverziók

Amennyiben egy kifejezésben különbözô típusú operandusok fordulnak elô, úgy a kiérté­ke­léshez az­ operandusokat azonos típusúakká kell alakítani. A típuskonver­ziónak két fajtája van : automatikus és kikényszeritett.

Automatikus típuskonverzió

Általános szabály :Ha az operandusok különbözô típusúak, akkor az alacsonyabbik típusú ala­kul át magasabb típusúvá, a műveletek elvégzése elôtt. Az eredmény maga­sabb típusú lesz.

Konkrétan :

char és short mennyiségek int típusúvá alakulnak át, a float mennyiségek double típu­­sú­vá. Ezért van értelme pl. annak, hogy : q = '1' ; k = q - '0' ; /* k értéke 1 lesz a 49 - 48 művelet miatt */

relációs ill. logikai kifejezések értéke 1, ha a kifejezés értéke igaz, és 0 ha hamis. Például : a=2 ; b=2 ;

c = (a == b) ; /* c értéke 1 lesz */
c = (a != b) ; /* c értéke 0 lesz */

ezután ha az egyik operandus long double, akkor a másik is az lesz és az eredmény is.

ezután ha az egyik operandus double, akkor a másik is az lesz és az ered­mény is.

egyébként ha az egyik operandus long, akkor a másik is az lesz és az ered­mény is.

egyébként ha az egyik operandus unsigned, akkor a másik is az lesz és az ered­mény is.

egyébként az operandusoknak int típusúaknak kell lenniük és az eredmény is az lesz.

- az értékadás szintén típuskonverzióval jár : a jobboldal értéke átalakul a bal­­oldal típusának megfelelően. A float-ból int-be történô konverzió atörtrész levágását e­redményezi. A double-bôl float-tá történô konverzió kerekítéssel törté­nik.

függvényeknek történô argumentumátadás esetén a char és a short típusok int-té válnak, a float típus double típusúvá !

Kikényszerített típuskonverzió - cast operátor

Alakja : (típusnév) kifejezés.
A könyvtári gyökvonó függvény ( sqrt ) be­me­nô para­méterül double típusú vál­­to­zót vár. Ha int típusból akarunk gyököt von­ni, úgy típuskonverziót kell alkalmazni :
int n = 9;
double eredm;
eredm = sqrt( (double) n ) ; /* eredm értéke 3.000000 lesz */

Az eddig tanult operátorok precedencia táblázata

Operátor Asszociativitás () balról jobbra

!, ~, ++, --, -, (tipus), sizeof jobbról balra
*, /, % balról jobbra
+, - balról jobbra
<<, >> balról jobbra
<, <=, >, >= balról jobbra
==, != balról jobbra
& balról jobbra
^ balról jobbra
| balról jobbra
&& balról jobbra
|| balról jobbra
=, +=, -=, *=, /=, %= jobbról balra

Fontos : Az olyan típusú kifejezések esetén mint az x = f() + g(); , ahol f és g két függvény nem tudjuk, hogy a fordító elôször f-et és utána g-t számítja ki, vagy for­dítva. Igy, ha akár f akár g olyan változót módosít, amelytôl a másik függ, x ér­téke függhet a ki­érté­­­kelési sorrendtôl. ( Mellékhatás jelensége ! )

Megoldás :Átmeneti változók használata.
z = f() ; /* Elôször f() -et számoljuk */
w = g() ; /* Utána g() -t számoljuk */
x = z + w ; /* Meghatározzuk a műveletvégzés sorrendjét */

Assszociativitás: azt mondja meg, hogy, az adott precedenciaszinten található műveleteket balról-jobbra vagy jobbról-balra haladva kell elvégezni.