c operators arithmetic
java programmation entretien questions et réponses pour expérimenté
Les opérateurs en C # sont des symboles spéciaux pour désigner l'opération que le programme doit effectuer. Ce didacticiel explique en détail les opérateurs C # avec des exemples:
Dans notre didacticiel précédent, nous avons découvert les instructions conditionnelles en C #. Nous avons également appris à utiliser les instructions if, if-else et if-else if pour définir différentes conditions.
Une déclaration conditionnelle telle que «si» est également appelée déclaration de prise de décision car elle fournit à l'utilisateur un mécanisme pour définir un résultat basé sur une décision définie par les opérateurs.
Les opérateurs offrent un moyen de définir des décisions basées sur la logique, les opérations arithmétiques, la comparaison, etc.
=> Voir notre série complète de formations C # ici
Ce que vous apprendrez:
Opérateurs C #
Les opérateurs en C # sont des symboles spéciaux qui indiquent l'opération que le programme doit effectuer sur les opérandes. Par exemple, ils peuvent être utilisés pour évaluer une variable ou effectuer une opération sur une variable pour créer une expression correcte.
C # offre une grande variété d'opérateurs tels que les opérateurs arithmétiques, les opérateurs relationnels, les opérateurs d'affectation, les opérateurs logiques, les opérateurs unaires, etc. Dans ce tutoriel, nous discuterons de certains des opérateurs importants ainsi que de leur utilisation.
Opérateurs arithmétiques
L'opérateur arithmétique permet au programme d'effectuer des opérations algébriques générales sur des valeurs numériques.
Il y a cinq opérateurs de base présents dans le langage de programmation C #.
- Ajout (symbole «+»): Effectuez l'ajout d'opérandes.
- Soustraction (symbole «-»): Effectue la soustraction d'opérandes.
- Division (symbole «/»): Effectue la division des opérandes.
- Multiplication (symbole «*»): Effectue une multiplication sur les opérandes.
- Module (symbole «%»): Renvoie un rappel après la division d'un entier.
Exemple:
int a = 10; int b = 5; int result; result = a + b; result = a - b; result = a * b; result = a / b; result = a % b;
- Le résultat de la première opération sera 15, c'est-à-dire la somme de deux entiers.
- Le résultat de la seconde opération sera 5, c'est-à-dire soustraction de deux entiers.
- Le résultat de la troisième opération sera 50, c'est-à-dire multiplication entre deux entiers.
- Le résultat de la quatrième opération sera 2, c'est-à-dire la sortie de la division de deux entiers.
- Le résultat de la cinquième opération sera 0 car il n'y aura plus de rappel lorsque deux entiers donnés seront divisés.
Il ne faut pas oublier que le résultat de l'opération dépendra du type de données utilisé pour stocker le résultat.
Ainsi, si la division de deux valeurs entières renvoie une valeur flottante et si le résultat est affecté à une variable entière, la partie décimale sera perdue en raison de types de données différents. Pour en savoir plus sur les types de données et la conversion, veuillez visitez notre précédent tutoriel.
L'opérateur module est différent des autres opérateurs, il renvoie la valeur du rappel à partir de la division des entiers. Disons que si nous divisons 20 par 6, alors l'opérateur de division renverra une réponse comme 3 (le quotient) et l'opérateur de module renverra 2, c'est-à-dire le rappel de la division.
Outre les 5 opérateurs définis ci-dessus, C # propose également deux opérateurs spéciaux qui augmentent ou diminuent la valeur d'une variable de 1.
Ceux-ci sont:
- Opérateur d'incrément : Désigné par le symbole «++»
- Opérateur de décrémentation : Désigné par le symbole «- -»
Ces opérateurs peuvent être prédéfinis ou suffixés avec des variables pour l'opération.
Exemple:
int a = 10; int b = 5; int increment; int decrement; increment = a++; decrement = b--;
Dans l'exemple ci-dessus, la réponse pour l'incrémentation sera 11, c'est-à-dire que la valeur de a sera augmentée de 1. Alors que la réponse pour la décrémentation sera 4, c'est-à-dire que la valeur de b sera diminuée de 1.
Opérateurs relationnels
Toute relation entre les deux opérandes est validée à l'aide d'opérateurs relationnels. Les opérateurs relationnels renvoient des valeurs booléennes. Si la relation entre deux opérandes est validée avec succès, elle retournera «true» et si la validation échoue, «false» sera retourné.
Les opérateurs relationnels sont principalement utilisés dans la prise de décision ou pour définir les conditions des boucles.
Jetons un coup d'œil aux opérateurs relationnels proposés par C #:
- Opérateur supérieur à: (désigné par «>»): Valide plus que la relation entre les opérandes.
- Moins que l'opérateur: (indiqué par '<“): Validates less than the relation between operands.
- Égal à l'opérateur: (noté «==»): valide l'égalité de deux opérandes.
- Supérieur ou égal à (désigné par «> =»): Valide supérieur ou égal à la relation entre les deux opérandes.
- Inférieur ou égal à (indiqué par '<=”): Validates less than or equals to the relations between the two operands.
- Inégal: (noté «! =»): Valide une relation non égale entre les deux opérandes.
int a = 10; int b = 5; bool validate; validate = a > b; //1 Console.WriteLine(validate); validate = a = b; //4 Console.WriteLine(validate); validate = a <= b; //5 Console.WriteLine(validate); validate = a != b; //6 Console.WriteLine(validate);
La sortie du programme ci-dessus sera:
- a> b renverra «True».
- à
- a == b renverra «False».
- a> = b renverra «Vrai» car a est supérieur à b et l'opérateur recherche une évaluation réussie de l'une des conditions données pour renvoyer une valeur vraie. Comme l'exemple donné renvoie «True» dans les deux cas, l'opérateur retournera true.
- à<=b will return “False” as a is neither less than b nor equal to b.
- a! = b retournera «True» car a n'est pas égal à b.
Opérateurs d'affectation
Les opérateurs d'affectation sont utilisés pour attribuer une valeur à une variable. Ceux-ci sont généralement utilisés avant un opérateur arithmétique.
Jetons un coup d'œil aux opérateurs d'affectation proposés par C #:
(i) Égale à («=»): C'est l'un des opérateurs d'affectation les plus simples. Il assigne la valeur d'un opérande à un autre. c'est-à-dire la valeur de l'opérande du côté droit à l'opérande du côté gauche.
Examp le: a = b
(ii) Ajouter Equal à l'opérateur d'affectation: Comme son nom l'indique, il s'agit d'une combinaison de plus «+» et égal à «=». Il s'écrit «+ =» et ajoute l'opérande du côté droit à l'opérande gauche et stocke la valeur finale dans l'opérande gauche.
Exemple: a + = b signifie (a = a + b)
(iii) Soustraire l'opérateur d'affectation d'égalité: Similaire à l'addition égale, il soustrait la valeur de l'opérande de droite de l'opérande de gauche, puis affecte la valeur à l'opérande de gauche.
Exemple: a - = b signifie (a = a-b)
(iv) Division égale à l'opérateur d'affectation: Il divise la valeur de l'opérande de droite par l'opérande de gauche, puis stocke le résultat dans l'opérande de gauche.
Exemple: a / = b moyenne (a = a / b)
(v) Multiplier égal à l'opérateur d'affectation: Il multiplie la valeur de l'opérande de droite par l'opérande de gauche, puis stocke le résultat dans l'opérande de gauche.
Exemple: a * = b moyenne (a = a * b)
(vi) Module égal à l'opérateur d'affectation: Il trouve le module de l'opérande gauche et droit et stocke la valeur dans l'opérande gauche.
Exemple:
a %=b means (a= a%b)
Ci-dessous est un programme pour avoir plus de clarté:
int a = 10; int b = 5; a += b; //1 Console.WriteLine(a); a -= b; //2 Console.WriteLine(a); a /= b; //3 Console.WriteLine(a); a *= b; //4 Console.WriteLine(a); a %= b; //5 Console.WriteLine(a);
Production
- La première valeur renverra 15, c'est-à-dire a = a + b.
- Le deuxième opérateur renverra 10, c'est-à-dire a = a-b.
- Le troisième opérateur renverra 2, c'est-à-dire a = a / b.
- Le quatrième opérateur renverra 50, c'est-à-dire a = a * b.
- Le cinquième opérateur renverra 0, c'est-à-dire a = a% b.
Opérateurs logiques
Les opérateurs logiques sont utilisés pour effectuer des opérations logiques. Les opérateurs logiques fonctionnent avec des expressions booléennes et renvoient une valeur booléenne. Les opérateurs logiques sont utilisés avec les opérateurs conditionnels dans les boucles et les déclarations de prise de décision.
Les opérateurs logiques et leur utilisation.
# 1) Opérateur ET logique
Symbole: '&&'
L'opérateur AND renvoie true lorsque les deux valeurs sont vraies. Si l'une des valeurs est false, elle retournera false.
Par exemple, A && B renverront true si A et B sont tous les deux vrais, si l'un d'entre eux ou les deux sont faux alors il retournera faux.
# 2) Opérateur OU logique
Symbole: '||'
L'opérateur OR renvoie vrai si l'une des conditions / opérandes est vraie. Il renverra faux lorsque les deux opérandes sont faux.
Par exemple, A || B renvoie vrai si la valeur de A ou B est vraie. Il retournera false si A et B ont des valeurs fausses.
# 3) Opérateur NOT logique
Symbole: '!'
L'opérateur NOT est utilisé pour inverser la conclusion logique de toute condition. Si la condition est vraie, elle retournera faux et si la condition est fausse, elle retournera vrai.
Exemple, ! (A || B) renvoie faux si «A || B» renvoie vrai et retournera vrai si «A || B» renvoie faux.
Exemple de programme:
int a = 10; int b = 5; bool result; // AND operator result = (a == b) && (a>b) Console.WriteLine(result); //OR Operator result = (a == b) || (a>b) Console.WriteLine(result); //NOT Operator result = !((a == b) || (a>b)) Console.WriteLine(result);
La sortie du programme ci-dessus sera:
- La première valeur retournera false comme l'une des conditions, c'est-à-dire que a == b est false.
- Le deuxième opérateur retournera vrai comme l'une des conditions, c'est-à-dire que a> b est vrai.
- Le troisième opérateur retournera false, c'est-à-dire la négation du résultat de l'opérateur OR.
Conclusion
Dans ce didacticiel, nous avons découvert les différents types d'opérateurs dans le langage de programmation C #. Nous avons appris l'utilisation et les symboles de ces opérateurs. L'opérateur arithmétique est utilisé par le programme pour effectuer des opérations algébriques simples comme l'addition, la soustraction, la multiplication, la division, etc.
Les opérateurs relationnels sont ceux qui sont utilisés pour valider une relation entre les deux opérandes comme s'ils étaient égaux, supérieurs à, inférieurs à, etc. Les opérateurs d'affectation sont utilisés pour affecter des valeurs à une variable. Un exemple le plus simple de l'opérateur d'affectation est «égal à». Les opérateurs logiques sont utilisés pour effectuer des opérations logiques telles que AND, OR, NOT, etc.
Les opérateurs sont largement utilisés pour déclarer des conditions dans des déclarations de prise de décision, lors de l'utilisation de boucles ou lors de l'exécution d'opérations algébriques.
=> Consultez notre guide de formation ultime C # ici
lecture recommandée
- Exemples d'opérateurs arithmétiques et booléens de script shell Unix
- Instructions conditionnelles Unix: If Then Else et opérateurs relationnels
- Opérateurs, types et exemples C ++
- Opérateurs Python
- Opérateurs Nouveau / Supprimer en C ++ avec des exemples
- Constantes, opérateurs et priorité des opérateurs dans VBScript
- Revue de la base de données relationnelle Open Source Altibase
- Corrélation et actions logiques dans Neoload Tool