Opérateurs de composés Arduino
Quels sont les opérateurs composés à Arduino
Dans la programmation Arduino, les opérateurs sont très importants car ils influencent la sortie d'un programme. Le mot composé signifie un composite de deux ou plusieurs choses. De même, les opérateurs composés sont un composite de deux opérateurs. En d'autres termes, pour effectuer deux opérations dans une déclaration, un opérateur composé est utilisé. Il existe essentiellement neuf types d'opérateurs composés qui sont discutés en détail.
Opérateur de multiplication composé (* =)
Cet opérateur a deux opérateurs, l'un est la multiplication et un autre est utilisé pour attribuer n'importe quelle valeur à toute variable ou constante. L'opérateur de multiplication composé peut être utilisé en utilisant l'astérisque avec des opérateurs égaux "* =". Pour stocker le résultat de l'opération, aucune troisième variable n'est requise .Le résultat peut être stocké dans l'une des deux variables qui doivent être multipliées.
Par exemple, si nous supposons qu'il existe deux variables A et B de type entier de type de données et en programmation Arduino si nous devons les multiplier à l'aide de l'opérateur de multiplication composé. La sortie sera stockée dans la variable A. Ici, la valeur de A est 4 et la valeur de B est 2, donc le résultat pour la multiplication sera de 8:
int a = 4;
int b = 2
void setup()
En série.commencer (9600);
En série.print ("Opérateur de multiplication composé:");
a * = b;
En série.println (a);
VOID LOOP ()
Sortir
Opérateur de division composé (/ =)
L'opérateur de division composé est une combinaison d'un opérateur d'affectation (=) et l'opérateur de division (/). Cet opérateur de la programmation Arduino peut être utilisé en utilisant des slash avant avec des égaux aux opérateurs "/ =". Une fois la division effectuée, le résultat est stocké dans une variable à gauche.
Par exemple, si deux variables ayant soit un type de données de flotteur ou un type de données entier. Supposons que la variable A ait une valeur de 4 et que la variable B a une valeur de 2 La réponse pour la division sera 2.
int a = 4;
int b = 2;
void setup()
En série.commencer (9600);
En série.print ("Opérateur de division composé:");
a / = b;
En série.println (a);
VOID LOOP ()
Sortir
Opérateur d'addition de composé (+ =)
Pour effectuer le fonctionnement mathématique de SUM et pour attribuer le résultat à l'une des variables, l'opérateur d'addition de composé est utilisé. Cet opérateur est représenté par (+ =). Supposons qu'il existe deux variables A, B et l'opérateur d'addition de composé doit être appliqué à l'aide de la programmation Arduino. Par exemple, si la variable a a une valeur de 4 et que la variable B est attribuée à la valeur 2, le résultat de l'application de l'opération d'addition sera 6.
int a = 4;
int b = 2;
void setup()
En série.commencer (9600);
En série.print ("Opérateur d'addition de composé:");
a + = b;
En série.println (a);
VOID LOOP ()
Sortir
Opérateur de soustraction composé (- =)
Lorsque la soustraction de deux variables doit être nécessaire dans la programmation Arduino, l'opérateur de soustraction et l'opérateur d'attribution sont utilisés pour stocker le résultat de l'opérateur de soustraction. Ensemble, ils fabriquent des opérateurs de soustraction composés et peuvent être utilisés en utilisant le "- =" signe. Pour supposer en outre que la valeur de la variable A est 4 et la valeur de la variable B est 2 et l'opérateur de soustraction composé est appliqué en programmation Arduino, le résultat sera 2:
int a = 4;
int b = 2;
void setup()
En série.commencer (9600);
En série.print ("Opérateur de division composé:");
a - = b;
En série.println (a);
VOID LOOP ()
Sortir
Incrément (++) et décrément (-)
L'opérateur incrémental augmente la valeur de un, mais l'opérateur de décrément diminue la valeur de toute variable de. L'opérateur incrémentiel peut être représenté par le «++» signe tandis que l'opérateur de décrément peut être utilisé en utilisant le "-" signe.
Par exemple, supposons qu'une variable I a une valeur de 1 et que la valeur de J est 2. L'opérateur d'incrément est appliqué sur la variable I et la sortie sera 2. Cependant, l'opérateur de décréments est appliqué sur la variable J et le résultat de la diminution sera de 1:
int i = 1;
int j = 2;
void setup()
En série.commencer (9600);
En série.print ("Opérateur d'incrément composé:");
i ++;
En série.println (i ++);
En série.Print ("Composé Decrément Operator:");
J-;
En série.println (j--);
VOID LOOP ()
Sortir
Opérateur de modulo composé (% =)
Pour trouver le reste lorsque deux nombres qui ne sont pas également divisés en programmation Arduino et pour attribuer la réponse à l'une des variables, l'opérateur de modulo composé est utilisé. Pour utiliser cet opérateur le signe "% =" est utilisé. Pour expliquer davantage l'utilisation de l'opérateur de modulo composé dans Arduino, nous pouvons prendre un exemple; Supposons que la valeur d'une variable A soit 4 et que la valeur pour B est 3 car elles ne sont pas complètement divisibles, donc le reste obtenu par l'opération de modulo sera de 1:
int a = 4;
int b = 3;
void setup()
En série.commencer (9600);
En série.print ("Opérateur de modulo composé:");
un% = b;
En série.println (a);
VOID LOOP ()
Sortir
Composé bitwise ou opérateur (| =)
Cet opérateur composé est représenté en utilisant "| =". Cet opérateur convertit d'abord les entiers en forme binaire et fonctionne petit à petit sur le binaire de l'entier converti.
Supposons que la valeur de la variable A est 4 et que son binaire est (0100) et que, de même, la valeur de la variable B est 2 et son binaire est (0010) et si le composé ou l'opérateur est utilisé, il s'appliquera ou fonctionne sur chaque bit de a et b. La sortie de l'opérateur ou ne sera nulle que si les deux sorties sont nulles. Dans ce cas, le résultat du composé ou de l'opération sera (0110) qui est de 6:
int a = 4;
int b = 2;
void setup()
En série.commencer (9600);
En série.print ("Composé bitwise ou opérateur:");
a | = b;
En série.println (a);
VOID LOOP ()
Sortir
Composé bitwise et opérateur (& =)
Un autre opérateur booléen qui peut être utilisé dans la programmation Arduino pour effectuer un fonctionnement logique est l'opération et l'opération. Un autre opérateur utilisé avec l'opérateur et l'opérateur affectant. Combinant l'opérateur et l'opérateur et l'opérateur d'affectation forment un composé et l'opérateur. Pour utiliser cet opérateur composé dans la programmation Arduino, le panneau utilisé est «& =". L'opérateur et l'opérateur OR fonctionne également petit à petit. Cependant, la sortie et l'opérateur est une seule si les deux entrées sont une et vice versa.
Par exemple, si le composé et l'opérateur sont appliqués sur les variables A et B ayant des binaires de (0100) pour 4 et (0010) pour 2, le résultat sera (0000) qui est 0.De même, deux autres variables C et D ayant des valeurs de 5 (0101) et 7 (0111) sont supposées et l'opération est appliquée sur les deux valeurs que le résultat pour le C et D est 5 (0101).
int a = 4;
int b = 2;
int c = 5;
int d = 7;
void setup()
En série.commencer (9600);
En série.print ("Composé bitwise et opérateur sur A et B:");
a & = b;
En série.println (a);
En série.print ("Composé bitwise et opérateur sur C et D:");
c & = d;
En série.println (c);
VOID LOOP ()
Sortir
Conclusion
Un opérateur composé utilisé dans la programmation Arduino est composé de deux opérateurs, l'un de l'opérateur assigné et l'autre est l'opérateur booléen ou tout opérateur mathématique. La signification des opérateurs composés est qu'ils sont utilisés pour les opérations logiques et arithmétiques requises dans la programmation Arduino et le résultat est également stocké vers l'opérande gauche en utilisant la fonction Assign. Dans cet article, neuf différents types d'opérateurs composés qui sont couramment utilisés dans la programmation Arduino sont brièvement discutés et pour donner une idée claire de l'utilisation de ces opérateurs avec des exemples.