Bitwise Operations Tutorial 

Dit keer ga ik het over operators die bits kunnen wijzigen, dit doe ik met C++.

 

 

Bitwise Operators

Met bitwise operators kun je heel wat doen, bovendien zijn ze ook nog heeeeeel snel!

Ze zijn nog sneller dan de  *  /  %  tekens(beweert men…). Het stukje “Bit” in “Bitwise” heeft natuurlijk een betekenis,

deze operators werken namelijk met het Binaire Getallensysteem, waar ik recent een tutorial over heb geschreven.

Je kunt met de bitwise operators snel bits verschuiven en zo een geheel nieuwe waarde aan een variabel geven.

 

 

De wijzigende SHIFT Operators

[eerst_gegeven_getal] [oper] [tweede_gegeven_getal]

eerst_gegeven_getal             is altijd een 1 of een 0.

oper                                        is de << of de >> operator.

tweede_gegeven_getal        is het aantal bits hij geschoven moet worden naar links of rechts.

 

Deze zijn de bitshifting operators. Ze zijn net twee kleine functies, ze nemen twee getallen en geven een waarde terug.

De shift operators hebben maar 1 variabel nodig, plus de schuifhoeveelheid.

De << schuift het eerst gegeven getal, het tweede gegeven getal aantal bits, op naar links.

De >> schuift het eerst gegeven getal, het tweede gegeven getal aantal bits, op naar rechts.

Dus:

 

int nValue = 1 << 2;    // Hier wordt een 1, twee bits opgeschoven naar links.

                        // 0000 0001 wordt:

                              // 0000 0010 wordt:

                        // 0000 0100 == 4

 

nValue = nValue >> 1;   // Hier wordt de 1, één bit terug geschoven naar rechts.

                        // 0000 0100 wordt:

                        // 0000 0010 == 2

 

Als nValue nu meerdere enen is, bijv: 0000 0011 == 3 dan worden alle enen opgeschoven:

 

int nValue = 3;         // 0000 0011 wordt:

nValue = nValue << 3;   // 0001 1000 == 24

 

Deze operators zijn vooral handig als het om checks gaat. Je hebt bijvoorbeeld 5 verschillende dingen zoals wapens.

Je weet hoe het werkt met FirstPerson Shooters, je kan scrollen om de volgende of vorige wapen te kiezen.

Heel handig natuurlijk… Ik weet niet of ze in professionele games het zo doen, maar met bits gaat het wel op deze manier:

 

int nCurrentWeapon = 1;                        // 0000 0001

 

if( ScrollUp() == true )                       // ScrollUp() is hierbij ff een functie die

{                                              // kijkt of je omhoog scrolled of niet.

  if( nCurrentWeapon != (1<<4) )               // Als nCurrentWeapon niet bit- en wapennummer 5 is:

  {

      nCurrentWeapon == nCurrentWeapon<<1;     // Shift de bit naar links

  }
}

if( ScrollDown() == true )                     // ScrollDown() is een functie die

{                                              // kijkt of je omlaag scrolled of niet.

  if( nCurrentWeapon != 1 )                    // Als nCurrentWeapon niet nummer 1 is:

  {

      nCurrentWeapon == nCurrentWeapon>>1;     // Shift de bit naar rechts

  }
}

 

De vergelijkende AND Operator 

[eerst_gegeven_getal][oper][ tweede_gegeven_getal]

eerst_gegeven_getal             is de eerste factor variabel.

oper                                        is de & operator.

tweede_gegeven_getal        is de tweede factor variabel.

 

De logical AND operator zorgt ervoor dat uit de gegeven getallen een nieuw getal komt.

De AND operator vergelijkt de twee variabelen met elkaar doormiddel van de bits.

Als beide bits allebei 1 zijn, zal de uitkomst van die bit van die positie 1 zijn.

Maar er zijn drie gevallen waar bits niet beide 1 kunnen zijn, nl. 0’0, 0’1, 1’0, bij deze drie gevallen wordt de uitkomst van die bit 0 zijn.

Tabel:

 

0 & 0 = 0

0 & 1 = 0

1 & 0 = 0

1 & 1 = 1

 

Voorbeelden:

 

int nFactor1 = 5;                        // nFactor1 == 0000 0101

int nFactor2 = 1;                        // nFactor2 == 0000 0001

int nUitkomst = (nFactor1 & nFactor2);   // 0000 0101

                                         // 0000 0001 &

                                         // 0000 0001

                                         // nUitkomst == 1

 

int nFactor1 = 1;                        // nFactor1 == 0000 0001

int nFactor2 = 0;                        // nFactor2 == 0000 0000

int nUitkomst = (nFactor1 & nFactor2);   // 0000 0001

                                         // 0000 0000 &

                                         // 0000 0000

                                         // nUitkomst == 0

 

De vergelijkende OR Operator

[eerst_gegeven_getal][oper][ tweede_gegeven_getal]

eerst_gegeven_getal             is de eerste factor variabel.

oper                                        is de | operator.

tweede_gegeven_getal        is de tweede factor variabel.

 

De logical OR operator zorgt net zoals de AND operator ervoor dat uit de gegeven getallen een nieuw getal komt.

Maar de berekening van deze operator verschilt(duh!). De OR operator vergelijkt de variabelen en maakt in de uitkomst variabel een bit

1 als 1 van de factorbits 1 is. Dat zijn 3 gevallen, nl. 0’1, 1’0, 1’1. Bij het andere geval, 0’0, wordt de uitkomst van die bit 0.

Tabel:

 

0 | 0 = 0

0 | 1 = 1

1 | 0 = 1

1 | 1 = 1

 

Voorbeeld:

 

int nFactor1 = 1;                        // nFactor1 == 0000 0001

int nFactor2 = 0;                        // nFactor2 == 0000 0000

int nUitkomst = (nFactor1 | nFactor2);   // 0000 0001

                                         // 0000 0000 |

                                         // 0000 0001

                                         // nUitkomst == 1

 

 

De vergelijkende XOR Operator

[eerst_gegeven_getal][oper][ tweede_gegeven_getal]

eerst_gegeven_getal             is de eerste factor variabel.

oper                                        is de ^ operator.

tweede_gegeven_getal        is de tweede factor variabel.

 

De XOR operator is een hele vreemde operator maar ook een hele handige.

De uitkomst 0 wordt bepaalt door het feit dat bij beide variabelen dezelfde bit is, dit zijn de combinaties van 1’1 en 0’0.

Bij de combinaties 1’0 en 0’1 zou er 1 uitkomen.

Tabel:

 

0 & 0 = 0

0 & 1 = 1

1 & 0 = 1

1 & 1 = 0

 

Voorbeeld:

 

int nFactor1 = 1;                        // nFactor1 == 0000 0001

int nFactor2 = 1;                        // nFactor2 == 0000 0001

int nUitkomst = (nFactor1 ^ nFactor2);   // 0000 0001

                                         // 0000 0001 ^

                                         // 0000 0000

 

De toets

Guess what times it is? Toets-time! Klik op de buttons voor de antwoorden! Veel succes!

 

Voorbeelden:

 

0001 0001         0001 0001         0001 0001

0001 0000 &       0001 0000 |       0001 0000 ^

0001 0000         0001 0001         0000 0001

 

Opgaven:

 

0101 1101         1101 0101         0101 0111

0101 0101 &       0101 0101 |       0101 0101 ^

                                      

 

 

Dat was het alweer,