C # != Opérateur d'inégalité

Ce guide d'indice Linux parlera de l'opérateur d'inégalité (!=) Dans la langue C # (C Sharp). L'opérateur d'inégalité (!=) est un opérateur relationnel. Le relationnel exploite la relation de deux expressions ou valeurs. En mathématiques, nous étudions les inégalités. Ils démontrent la relation des expressions qui ne sont pas égales. Ils sont au nombre de six et l'opérateur d'inégalité (!=) est l'un de ceux. Il illustre comment les expressions se rapportent les unes aux autres lorsqu'elles ne sont pas égales. Tout en prenant des décisions, nous utilisons cet opérateur. Ils sont utilisés dans des déclarations de prise de décision comme la déclaration «IF». Nous pouvons les utiliser n'importe où dans la boucle. Mais nous ne pouvons utiliser cet opérateur à l'intérieur de la déclaration de décision pour prendre une décision.

Syntaxe

Exp_1 != Exp_2 -

L'opérateur d'inégalité est très utile lorsque nous devons prendre une décision. La syntaxe est très facile. Définir deux expressions dire "exp_1" et "exp_2". Entre ces deux expressions, utilisez l'opérateur d'inégalité (!=).

L'opérateur fonctionne en retournant True lorsque l'une ou l'autre des deux expressions n'est pas égale à l'autre. Le nom lui-même dit que «l'inégalité» est lorsque deux expressions ou valeurs ne sont pas égales les unes aux autres. La condition devient vraie et exécute le corps de l'énoncé de décision. L'énoncé de décision peut être si, else-if ou commutateur. Et lorsque la valeur ou l'expression est égale, la condition devient fausse et ne va pas dans le corps de l'énoncé de décision.

Exemple non. 1

Dans ce code, nous apprendrons à vérifier si les deux nombres de type entier sont égaux:

Utilisation du système;
Programme de classe_0

statique void main ()
int Val_1 = 56;
int Val_2 = 18;
if (val_1 != Val_2)

Console.Écrire ("La somme des valeurs est:");
Console.WriteLine (VAL_1 + VAL_2);

Tout d'abord, à l'intérieur de la fonction Main () statique, déclarez deux variables de type entier. Le "Val_1" stockait la valeur entière de 56 et "Val_2" stocke la valeur entière de 18. Après avoir défini les variables, appliquez la déclaration «IF» pour prendre une décision. Dans le «si», utilisez les deux variables (Val_1 et Val_2) comme opérandes et écrivez l'opérateur d'inégalité (! =). Le corps de la déclaration «IF» imprimera un message à l'écran en appelant la console.Méthode écrite (). Après cela, il ajoutera les deux variables et représentera la valeur résultante sur la console. Le compilateur compilera le programme ligne par ligne. Il compilera les deux premières déclarations qui initialisent les variables. Il stockera les deux variables de la mémoire avec leurs valeurs. Ensuite, il compilera la déclaration «IF». Si la condition définie de la déclaration «IF» est vraie, alors son corps sera exécuté. Le compilateur obtiendra la valeur de "Val_1" et "Val_2" et comparera ces deux valeurs. Ne sont-ils pas égaux? Si oui, il renverra vrai et exécutera le corps de la déclaration «IF». Chaque fois qu'il revient faux, le compilateur ignore simplement le corps et passe à l'étape suivante. Lorsque l'instruction «IF» renvoie vrai, le corps sera exécuté et affichera un texte avec une somme des deux valeurs.

Exemple non. 2

Cette instance simplifiera l'utilisation de l'opérateur d'inégalité (!=) Pour les valeurs du point flottant.

Utilisation du système;
Programme de classe_1

statique void main ()
Float Value_1 = 6.9f;
Float Value_2 = 8.7f;
if (value_1 != Valeur_2)

Console.Écrire ("Le résultat des valeurs après la division est:");
Console.WriteLine (Value_1 / Value_2);

autre
Console.Écrire ("Le résultat des valeurs après la multiplication est:");
Console.WriteLine (Value_1 * Value_2);

Le code commence par initialiser deux valeurs de point flottantes. Dans l'instruction suivante, utilisez une instruction IF-ELSE pour déterminer si les deux valeurs sont égales ou non. Dans l'instruction «IF», ​​définissez la condition, valeur_1 != Valeur_2. Dans le corps de «si», utilisez la console.Méthode écrite () pour écrire le message sur la console. Après cela, la console de la méthode.WriteLine () est appelé pour afficher le résultat de deux variables après la division. Si la condition définie est fausse, exécutez la partie «else» avec deux instructions à afficher sur la console. Mais dans la partie «else», nous multiplierons les deux variables en utilisant l'opérateur «*». Le compilateur exécutera l'instruction «IF» et évaluera si les deux valeurs sont identiques. S'ils sont égaux, alors le corps de «IF» sera implémenté, et la première valeur, «Value_1», sera divisée par le deuxième «Value_2». Sinon, alors la partie «Else» sera exécutée, et les valeurs de «Value_1» et «Value_2» seront multipliées.

Exemple non. 3

Dans cet exemple, nous explorons le fonctionnement de l'opérateur d'inégalité (!=) dans la boucle «pour».

Utilisation du système;
Classe Program_2

statique void main ()
pour (int i = 10; i<20; i++)

si je != 19)

Console.WriteLine ("le" + i + "n'est pas égal à 19");

autre
Console.Writeline ("\ nthe" + i + "est égal à 19");

Après avoir appelé la fonction statique void main (), appliquez une boucle «pour» et initialisez l'itérateur. Dans la boucle «pour», utilisez l'instruction «IF» pour vérifier si les valeurs de boucle ne sont pas égales à 19. Et l'instruction «ELSE» sera mise en œuvre lorsque l'instruction «IF» renverra FALSE. La boucle «pour» irate dix fois, et les neuf fois, la déclaration «IF» reviendra vrai. Mais une seule fois, il exécutera la partie «else» parce que la valeur de l'itérateur et la valeur de condition deviendront égales, ce qui rend la déclaration «if» fausse. Le corps de «If» imprimera un message avec la valeur de l'itérateur. De même, le corps de la déclaration «else» utilise la console.Méthode writeLine () pour afficher le texte.

Exemple non. 4

Nous utiliserons l'opérateur d'inégalité au sein de la boucle à faire dans ce programme.

Utilisation du système;
programme de classe_3

statique void main ()
int i = 20;
faire

i + = 10;
si je != 40)

Console.WriteLine ("le nombre" + i + "n'est pas égal à 40");

autre
Console.WriteLine ("le nombre" + i + "est égal à 40");
alors que je<80);

La variable de type entier sera déclarée par la valeur de 20. Ensuite, utilisez une boucle «à faire» pour faire boucle pour une condition donnée. À l'intérieur de la partie «do», incrémentez le «je» avec 10. Ici, définissez la condition dans l'instruction «IF», ​​qui montre que la valeur de «i» ne doit pas être égale à 40. Si cette condition est satisfaite, le corps de l'instruction «if» fonctionnera, et si ce n'est pas le cas, la déclaration «else» fonctionnera. Un message contenant la valeur de «i» peut être vu en appelant la console.Méthode writeLine () dans le corps des déclarations «if» et «else».

Conclusion

Ce guide discute explicitement de l'opérateur d'inégalité (!=) et comment il est utilisé dans la langue C #. Pour résumer, nous avons appris à utiliser l'opérateur d'inégalité (!=) avec des valeurs entières, des valeurs de points flottants, si, if-else, pour la boucle et la boucle à faire. Il s'agit d'un opérateur relationnel qui est appliqué lorsque nous devons acquérir que les valeurs ne sont pas égales. Quand ils ne seront pas égaux, ils reviendront vrai.