online kép - Fájl  tube fájl feltöltés file feltöltés - adja hozzá a fájlokat online fedezze fel a legújabb online dokumentumok Kapcsolat
   
 

Letöltheto dokumentumok, programok, törvények, tervezetek, javaslatok, egyéb hasznos információk, receptek - Fájl kiterjesztések - fajltube.com

 

Online dokumentumok - kep
   

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

számítógépes

Fájl küldése e-mail Esszé Projekt

egyéb tételek

 
Fajltípusok
INTERNET ÉS KOMMUNIKÁCIÓ
Formalis nyelvek a gyakorlatban
Halózati szolgaltatasok
Az elektronikus szamítógépek fejlödése napjainkig - A generaciók jellemzése, perifériak valtozasa - Neumann elvek
Halózati szabvanyok, ajanlasok
Xara Webstyle
Internetes keresőrendszerek hasznalata (kulcs szavas, tematikus keresés)
Adatvezérlő nyelv
Az adatbazisok fejlődési trendjei
 
 

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.

                     int i;
                     float z,y;
                     ...
                     z = y + i;
                     /* i -bôl elôször float-ot csinál a program */

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.

Találat: 1242