Arduino – Operátorok

Az operátor olyan szimbólum, amely a fordítót arra utasítja, hogy hajtson végre bizonyos logikai vagy matematikai feladatokat. Vegyük őket sorra.

Matematikai operátorok

A hozzárendelés operátor az egyenlőségjel jobb oldalán lévő értéket eltárolja az egyenlőségjel bal oldalán lévő változóban. Nem tévesztendő össze az egyenlő összehasonlító operátorral „==”.

A = B;
int a = 10;

Az „X” és „Y” operandusok értékét, (ezek lehetnek változók vagy állandók) összeadjuk és az „A” változónak átadjuk. Az összeadás operátor szintaxisa.

A = X + Y;

A kivonás operátor, szerintem nem kell magyarázni.

A = X - Y;

A szorzás.

A = X * Y;

És az osztás.

A = X / Y;

Az „X” változót elosztjuk az „Y” változóval és az osztás maradékát átadjuk az „A” változónak. Az „A” változó adattípusa lehet int, float vagy double, az „X” és az „Y” csak int. A modulo operátor szintaxisa:

A = X % Y;
int a = 7 % 5;  // a --> 2

Összehasonlító operátorok

Az egyenlő operátor (dupla egyenlőségjel) „==” ellenőrzi, hogy két operandus értéke egyenlő-e vagy sem, ha igen, akkor a feltétel igaz lesz. Ha az „A” értéke megegyezik a „B” értékével akkor igaz lesz, ellenkező esetben hamis.

int A = 12;
int B = 15;
if(A == B)  // --> false

A nem egyenlő operátor „!=” ellenőrzi, hogy két operandus értéke egyenlő-e vagy sem, ha az értékek nem egyenlőek, akkor a feltétel igaz lesz. Nézzük a példát.

int A = 12;
int B = 15;
if(A != B)  // --> true

A kisebb mint operátor”<” összehasonlítja a bal oldali változót az operátor jobb oldalán lévő értékkel vagy változóval. A feltétel igaz lesz, ha a bal oldali operandus kisebb, mint a jobb oldali operandus, ellenkező esetben hamis.

int A = 12;
int B = 15;
if(A < B)  // --> true

A nagyobb mint operátor”>” összehasonlítja a bal oldali változót az operátor jobb oldalán lévő értékkel vagy változóval. A feltétel igaz lesz, ha a bal oldali operandus nagyobb, mint a jobb oldali operandus, ellenkező esetben hamis.

int A = 12;
int B = 15;
if(A > B)  // --> false

A kisebb vagy egyenlő operátor”<=” összehasonlítja a bal oldali változót az operátor jobb oldalán lévő értékkel vagy változóval. A feltétel igaz lesz, ha a bal oldali operandus kisebb vagy egyenlő, mint a jobb oldali operandus, ellenkező esetben hamis.

int A = 12;
int B = 15;
if(A <= B)  // --> true

A nagyobb mint operátor”>=” összehasonlítja a bal oldali változót az operátor jobb oldalán lévő értékkel vagy változóval. A feltétel igaz lesz, ha a bal oldali operandus nagyobb, mint a jobb oldali operandus, ellenkező esetben hamis.

int A = 12;
int B = 15;
if(A >= B)  // --> false

Logikai operátorok

A logikai és „&&” operátor mindkét operandusa igaz, akkor a feltétel igaz lesz, különben hamis.

int A = 12;
int B = 15;
if(A == 15  && B == 15)  // --> false

A logikai vagy „||” operátor legalább egyik operandusa igaz, akkor a feltétel igaz lesz.

int A = 12;
int B = 15;
if(A == 15  || B == 15)  // --> true

A logikai tagadás „!” operátor megfordítja az operandus logikai állapotát.

bool A = true;
if(!A)  // --> false

Bitenkénti operátorok

A bináris „és” „&”operator a kifejezés a byte minden bitpozícióján függetlenül működik. Ennek a szabálynak megfelelően: ha mindkét bemeneti bit 1, akkor a kapott kimenet 1, egyébként a kimenet 0.

0 0 1 1  // operand1
0 1 0 1  // operand2
-------
0 0 0 1  // (operand1 & operand2)

A bináris „vagy” „|” operátora kifejezés minden bitpozícióján függetlenül működik. Ha vagy az egyik bemeneti bit értéke 1 vagy a másik bemeneti bit értéke 1 vagy mindkettőé 1, akkor a kimenet 1 lesz. Ha mindkettő bemeneti bit értéke 0 a kimenet 0 lesz.

0 0 1 1 // operandus1
0 1 0 1 // operandus2
-------
0 1 1 1 // (operand1 | operand2)

A bináris „kizáró vagy” operátor „^”. A bitenkénti XOR művelet eredménye 1 ha a bemeneti bitek eltérnek, egyéb esetben 0.

0  0  1  1   // operand1 
0  1  0  1   // operand2 
----------
0  1  1  0   // (operand1 ^ operand2)

A bitenkénti „nem” operátor „~” invertálja a biteket. Az 1-ből 0 lesz.

0 0 1 1  // operand1
-------
1 1 0 0  // ~ operand1

A balra eltolás operátor „<<„. A „B” operandus értékét „C ” pozicióval toljuk balra. A „B” operandus bal oldali bitjei kitolódnak és elvesznek.

A = B << C;

int B = 5;      // binary: 0000000000000101
int A = B << 3; // binary: 0000000000101000
A == 40;

A jobbra eltolás operátor „>>”. A „B” operandus értékét „C ” pozicióval toljuk jobbra. A „B” operandus jobb oldali bitjei kitolódnak és elvesznek.

A = B >> C;

int B = 40;      // binary: 0000000000101000
int A = B >> 3;  // binary: 0000000000000101
A == 5;

Összetett operátorok

Az inkrementáló operátor „++” eggyel növeli a változó értékét. Ezt két különböző módon használhatjuk. Az első példában az „A” változó átadja az értékét a „B” változónak majd eggyel növeli az értékét. A második példában az „A” változó növeli az értékét, majd átadja az értékét a „B” változónak. Tehát nem mindegy, hogy az operandus melyik oldalán van az operátor.

int A = 3;
int B;
B = A++;
// A == 4
// B == 3

int A = 3;
int B;
B = ++A;
// A == 4
// B == 4

A dekrementáló operátor „- -” eggyel csökkenti a változó értékét. Ezt két különböző módon használhatjuk. Az első példában az „A” változó átadja az értékét a „B” változónak majd eggyel csökkenti az értékét. A második példában az „A” változó csökkenti az értékét, majd átadja az értékét a „B” változónak. Tehát nem mindegy, hogy az operandus melyik oldalán van az operátor.

int A = 3;
int B;
B = A--;
// A == 2
// B == 3

int A = 3;
int B;
B = --A;
// A == 2
// B == 2

A hozzáadás hozzárendelés operátor „+=” hozzáadja a jobb operandus értékét a bal operandus értékéhez, és az eredményt a bal operandushoz rendeli. A += B müvelet egyenértékű ezzel A = A + B.

int A = 3;
int B = 2;
A += B;
// A == 5

A kivonás hozzárendelés operátor „-=” kivonja a jobb operandus értékét a bal operandus értékéből, és az eredményt a bal operandushoz rendeli. A -= B müvelet egyenértékű ezzel A = A -B.

int A = 3;
int B = 2;
A -= B;
// A == 1

A szorzás hozzárendelés operátor „*=” megszorozza a bal operandus értékét a jobb operandus értékével, és az eredményt a bal operandushoz rendeli. A *= B müvelet egyenértékű ezzel A = A *B.

int A = 3;
int B = 2;
A *= B;
// A == 6

Az osztás hozzárendelés operátor „/=” a bal operandus értékét elosztja a jobb operandus értékével, és az eredményt a bal operandushoz rendeli. A /= B müvelet egyenértékű ezzel A = A / B.

int A = 8;
int B = 2;
A /= B;
// A == 4

Moduluo hozzárendelés operátor „%” a bal operandus értékét elosztja a jobb operandus értékével, és az osztás maradékát a bal operandushoz rendeli. A %= B müvelet egyenértékű ezzel A = A % B.

int A = 8;
int B = 5;
A %= B;
// A == 3

A bitenkénti vagy hozzárendelés operátort „|=” gyakran használják, hogy a változó bizonyos bitjeit „átállítsák”. A |= B müvelet egyenértékű ezzel A = A | B.

int myByte = 0b10101010;
int myMask = 0b00000011;
myByte |= myMask; 

// myByte == 0b10101011

1 0 1 0 1 0 1 0
0 0 0 0 0 0 1 1
---------------
1 0 1 0 1 0 1 1

A bitenkénti és hozzárendelés operátort „&=” arrat használják, hogy a változóban lévő bizonyos biteket 0-ra állítsanak. Ezt „bitek törlésének” vagy „visszaállításának” is nevezik. Tehát a maszkban szereplő nullák, nullára állítják a változó azonos helyen lévő bitjeit, közben a változó többi részét változatlanul hagyja. A &= B müvelet egyenértékű ezzel A = A & B.

int myByte = 0b10101010;
int myMask = 0b11111100;
myByte &= myMask; 

// myByte == 0b10101000

1 0 1 0 1 0 1 0
1 1 1 1 1 1 0 0
---------------
1 0 1 0 1 0 0 0

A bitenkénti XOR hozzárendelés operátort „^=” gyakran használják változóval és állandóval a változó bizonyos bitjeinek átkapcsolására (invertálására). Tehát a maszkban szereplő egyesek, egyre állítják a változó azonos helyen lévő nulláit, közben a változó többi részét változatlanul hagyja. A ^= B müvelet egyenértékű ezzel A = A ^ B.

int myByte = 0b10101010;
int myMask = 0b00000011;
myByte ^= myMask; 

// myByte == 0b10101001

1 0 1 0 1 0 1 0
0 0 0 0 0 0 1 1
---------------
1 0 1 0 1 0 0 1

Tökéletes a gyakorláshoz:

A következő rész a feltételes végrehajtást járja körül.

---