Arduino – Operatoren

Ein Operator ist ein Symbol, das den Compiler anweist, bestimmte logische oder mathematische Aufgaben auszuführen. Schauen wir sie uns an.

Mathematische Operatoren

Der Zuweisungs Operator speichert den Wert rechts vom Gleichheitszeichen in der Variablen links vom Gleichheitszeichen. Nicht zu verwechseln mit dem gleichen Vergleichsoperator „==“.

A = B;
int a = 10;

Die Werte der Operanden „X“ und „Y“ (dies können Variablen oder Konstanten sein) werden addiert und an die Variable „A“ übergeben. Syntax des Additions Operators.

A = X + Y;

Der Subtraktions Operator muss meiner Meinung nach nicht erklärt werden.

A = X - Y;

Die Multiplikation.

A = X * Y;

Und die Division.

A = X / Y;

Die Variable „X“ wird durch die Variable „Y“ geteilt und der Rest der Division wird an die Variable „A“ übergeben. Der Datentyp der Variablen „A“ kann int, float oder double sein, „X“ und „Y“ sind nur int. Syntax des Modulo-Operators:

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

Vergleichsoperatoren

Der Gleichheits Operator (doppeltes Gleichheitszeichen) „==“ prüft, ob die Werte zweier Operanden gleich sind oder nicht. In diesem Fall ist die Bedingung erfüllt. Wenn der Wert von „A“ mit dem Wert von „B“ übereinstimmt, ist er wahr, andernfalls ist er falsch.

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

Der Ungleich Operator „! =“ Überprüft, ob die Werte zweier Operanden gleich sind oder nicht. Wenn die Werte nicht gleich sind, ist die Bedingung erfüllt. Schauen wir uns ein Beispiel an.

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

Weniger als der Operator „<“ vergleicht die Variable links mit dem Wert oder der Variablen rechts vom Operator. Die Bedingung ist wahr, wenn der Operand links kleiner als der Operand rechts ist, andernfalls falsch.

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

Größer als der Operator „>“ vergleicht die Variable links mit dem Wert oder der Variablen rechts vom Operator. Die Bedingung ist wahr, wenn der Operand links größer als der Operand rechts ist, andernfalls falsch.

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

Der kleinere oder gleiche Operator „<=“ vergleicht die Variable links mit dem Wert oder der Variablen rechts vom Operator. Die Bedingung ist wahr, wenn der linke Operand kleiner oder gleich dem rechten Operanden ist, andernfalls falsch.

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

Größer als der Operator ”> =” vergleicht die Variable links mit dem Wert oder der Variablen rechts vom Operator. Die Bedingung ist wahr, wenn der Operand links größer als der Operand rechts ist, andernfalls falsch.

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

Logische Operatoren

Beide Operanden der Logik „und“ Operator „&&“ sind wahr, dann ist die Bedingung wahr, andernfalls falsch.

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

Das logische „oder“ „||“ Wenn mindestens ein Operand des Operators wahr ist, ist die Bedingung wahr.

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

Die logische „Nicht“ ist „!“ . Der Operator kehrt den logischen Zustand des Operanden um.

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

Bitweise Operatoren

Der „Bitweises UND“ „&“ arbeiten unabhängig an jeder Bitposition im Byte. Nach dieser Regel: Wenn beide Eingangsbits 1 sind, ist der resultierende Ausgang 1, andernfalls ist der Ausgang 0.

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

Der „bitweises OR“ „|“ Der Operator arbeiten unabhängig an jeder Bitposition im Byte. Wenn eines der Eingangsbits den Wert 1 oder das andere Eingangsbit den Wert 1 oder beides hat, ist der Ausgang 1. Wenn beide Eingangsbits auf 0 gesetzt sind, ist der Ausgang 0.

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

Der bitweises XOR Operator ist „^“. Das Ergebnis der bitweisen XOR-Operation ist 1, wenn die Eingangsbits unterschiedlich sind, andernfalls 0.

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

Der bitweise Nicht Operator „~“ invertiert die Bits. 1 wird 0.

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

Der“ Bitshift links“ ist „<<„. Bewegen Sie den Wert des Operanden „B“ mit der Position „C“ nach links. Die linken Bits des Operanden „B“ werden erweitert und gehen verloren.

A = B << C;

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

Der „Bitshift recht“ ist „>>“. Der Wert des Operanden „B“ wird um die Position „C“ nach rechts verschoben. Die Bits rechts vom Operanden „B“ werden erweitert und gehen verloren.

A = B >> C;

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

Komplexe Operatoren

Der inkrement Operator erhöht den Wert der Variablen um ein „++“. Dies kann auf zwei verschiedene Arten verwendet werden. Im ersten Beispiel übergibt die Variable „A“ ihren Wert an die Variable „B“ und erhöht dann ihren Wert um eins. Im zweiten Beispiel erhöht die Variable „A“ ihren Wert und übergibt ihren Wert dann an die Variable „B“. Daher ist es wichtig, auf welcher Seite des Operanden sich der Operator befindet

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

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

Der Dekrement Operator „- -“ verringert den Wert der Variablen um eins. Dies kann auf zwei verschiedene Arten verwendet werden. Im ersten Beispiel übergibt die Variable „A“ ihren Wert an die Variable „B“ und verringert dann ihren Wert um eins. Im zweiten Beispiel verringert die Variable „A“ ihren Wert und übergibt ihren Wert dann an die Variable „B“. Daher ist es wichtig, auf welcher Seite des Operanden sich der Operator befindet

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

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

Der Zusammengesetzte Addition „+ =“ addiert den Wert des rechten Operanden zum Wert des linken Operanden und weist das Ergebnis dem linken Operanden zu. Operation A + = B entspricht A = A + B.

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

Der Zusammengesetzte Subtraktion „- =“ subtrahiert den Wert des rechten Operanden vom Wert des linken Operanden und weist das Ergebnis dem linken Operanden zu. Operation A – = B entspricht A = A -B.

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

Der Zusammengesetzte Multiplikation „* =“ multipliziert den Wert des linken Operanden mit dem Wert des rechten Operanden und weist das Ergebnis dem linken Operanden zu. Operation A * = B entspricht A = A * B.

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

Der Zusammengesetzte Division „/ =“ dividiert den Wert des linken Operanden durch den Wert des rechten Operanden und weist das Ergebnis dem linken Operanden zu. Operation A = B entspricht A = A / B.

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

Der Zusammengesetzter Rest „%=“ dividiert den Wert des linken Operanden durch den Wert des rechten Operanden und weist den Rest der Division dem linken Operanden zu. Operation% = B entspricht A = A% B.

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

Der Zusammengesetztes Bitweises ODER Operator „| =“ wird häufig verwendet, um bestimmte Bits einer Variablen zu „ändern“. Operation A = B entspricht A = A | B. 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

Der Zusammengesetztes Bitweises AND Operator „& =“ wird verwendet, um bestimmte Bits in der Variablen auf 0 zu setzen. Dies wird auch als „Löschen von Bits“ oder „Wiederherstellen“ bezeichnet. Die Nullen in der Maske setzen also die Bits der Variablen an derselben Stelle auf Null, während der Rest der Variablen unverändert bleibt. Operation A = B entspricht 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

Der Zusammengesetztes Bitweises XOR Operator „^ =“ wird häufig mit einer Variablen und einer Konstanten verwendet, um bestimmte Bits der Variablen zu schalten (zu invertieren). Daher setzen einige in der Maske die Nullen der Variablen an derselben Stelle, wobei der Rest der Variablen unverändert bleibt. Operation A = B entspricht 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

Perfekt zum Üben:

Der nächste Abschnitt befasst sich mit der bedingten Ausführung.