Opérateurs logiques en C
En langue C Groupes d'opérateurs sont présents. Il existe sept types d'opérateurs présents. Ils sont:
- Unary
- Arithmétique
- Dans le monde
- Relationnel
- Logique
- Conditionnel
- Mission
En C, il existe une règle précédente qui existe en cas de groupes d'opérateurs. Si dans un problème, il y a plusieurs opérateurs présents, ce type de problème est résolu en fonction de cet ordre de groupes d'opérateurs.
L'opérateur logique est le membre de ces groupes d'opérateurs. Il existe trois types d'opérateurs logiques présents dans le langage C.
- PAS ! (1ère priorité)
- Et && (2e priorité)
- Ou || (3e priorité)
Pas opérateur
C'est aussi un opérateur unary. Le niveau de priorité est le même que les opérateurs unaires. Il inverse la valeur de vérité de la déclaration.
| 1 2 3 | ! T = f ! F = t |
Exemple de programmation 1
| 1 2 3 4 5 6 7 8 9 dix 11 12 13 | #inclure int main () int y, x = 5; y = !x> 4; printf ("Résultat est:% d", y); |
Sortir
Ici, trois opérateurs sont utilisés. Comme non l'opérateur n'a pas le niveau de priorité le plus élevé, pas l'opérateur s'exécute en premier. Donc, !x signifie pas de valeur non nulle est 0. Est maintenant 0> 4? Non. Donc le résultat est faux (zéro). Cela peut être fait à l'aide d'un opérateur plus élevé que (>). Ainsi, 0 est attribué en y à l'aide de l'opérateur d'affectation (=).
Donc, le résultat = 0.
Exemple de programmation 2
| 1 2 3 4 5 6 7 8 9 dix 11 12 13 14 15 16 17 | #inclure int main () int a, b; printf ("Entrez n'importe quel numéro:"); scanf ("% d", & a); b = !un ; printf ("Le résultat est:% d", b); retour 0; |
Sortir
Explication
L'exemple de programmation ci-dessus est d'opérateur logique. Ici, l'expression donnée de l'opérateur logique est:
| 1 | b = !un ; |
Ici, deux opérateurs sont utilisés. L'un est l'opérateur d'affectation (=), un autre est logique et non opérateur ( ! ). Comme l'opérateur logique et non plus prioritaire que l'opérateur d'affectation, l'opérateur logique et non exécuté s'exécute d'abord.
Ici, nous entrons un numéro par l'utilisateur. Le nombre est 56. C'est une valeur non nulle. Logical Not Operator se transforme en zéro. Ce zéro est affecté à la variable x à l'aide de l'opérateur d'affectation. Donc, le résultat sera nul.
Exemple de programmation 3
| 1 2 3 4 5 6 7 8 9 dix 11 12 13 14 | #inclure int main() int x = 10; int y; y = !( X != 10); printf ("Résultat est:% d", y); |
Sortir
Explication
L'exemple de programmation ci-dessus est d'opérateur logique. Ici, l'expression donnée de l'opérateur logique est:
| 1 | y = !( X != 10); |
Ici, quatre opérateurs sont utilisés. Deux opérateurs logiques et non ( ! ) et le reste de l'opérateur d'affectation (=). Comme non l'opérateur n'a pas le niveau de priorité le plus élevé, pas l'opérateur s'exécute en premier. Pas l'opérateur dans la première parenthèse s'exécute d'abord. Alors, «x!"Signifie pas de valeur non nulle est 0. Maintenant, ce zéro est affecté à X à l'aide de l'opérateur d'affectation. Maintenant "!0 ”signifie une valeur non nulle, qui est une vraie valeur. Cette vraie valeur à nouveau affectée à la variable Y à l'aide de l'opérateur d'affectation.
Donc, sortie du résultat = 1.
Et opérateur
| Énoncé 1 | && | Déclaration 2 | Résultat |
|---|---|---|---|
| FAUX | X | FAUX | |
| Vrai | FAUX | FAUX | |
| Vrai | Vrai | Vrai |
Exemple de programmation 4
| 1 2 3 4 5 6 7 8 9 dix 11 12 13 | #inclure int main () int y, x = 5; y = x> 4 && x<10 ; printf ("Résultat est:% d", y); |
Sortir
Ici && opérateur a combiné ces deux conditions. Si la 1ère déclaration est vérifiée, si la 1ère déclaration = false, donc le résultat global = 0. Seulement si les deux instructions sont vraies, alors sur tous les résultats sont vraies, sinon faux.
Dans ce programme, les deux déclarations sont «vraies». Donc, sortie du résultat = 1.
Exemple de programmation 5
| 1 2 3 4 5 6 7 8 9 dix 11 12 13 14 15 | #inclure int main() // DÉCLARDONS UNE VARIABLE A int a = 17; printf ("Résultat est:% d \ n", (a> = 20 && a<=50)) ; retour 0; |
Sortir
Explication
L'exemple de programmation ci-dessus est un autre exemple d'opérateur logique. Ici, l'expression donnée de l'opérateur logique est:
| 1 | a> = 20 && a<=50 ; |
Ici && opérateur a combiné ces deux conditions. Si la 1ère déclaration est vérifiée, si la 1ère déclaration = false, donc le résultat global = 0. Seulement si deux instructions sont vraies, alors le résultat global est vrai, sinon faux.
Dans ce programme, la première déclaration est «vraie». Le second est faux. Donc, la sortie globale du résultat = 0 comme une instruction est fausse.
Exemple de programmation 6
| 1 2 3 4 5 6 7 8 9 dix 11 12 13 14 15 16 | #inclure int main() // DÉCLARDONS UNE VARIABLE A int a = 10; int b = a!= 10 && a> = 5; printf ("Résultat est:% d \ n", (b)); retour 0; |
Sortir
Explication
L'exemple de programmation ci-dessus est un autre exemple d'opérateur logique. Ici, l'expression donnée de l'opérateur logique est:
| 1 | b = a!= 10 && a> = 5; |
Ici, && opérateur a combiné ces deux conditions. Si la 1ère déclaration est vérifiée, si la 1ère déclaration = false, donc le résultat global = 0. Seulement si deux instructions sont vraies, alors le résultat global est vrai, sinon faux.
Dans ce programme, la première déclaration est fausse. Le second n'est pas nécessaire de vérifier. Donc, la sortie globale du résultat = 0 comme une instruction est fausse.
Ou opérateur
| Énoncé 1 | && | Déclaration 2 | Résultat |
|---|---|---|---|
| FAUX | FAUX | FAUX | |
| FAUX | Vrai | Vrai | |
| Vrai | X | Vrai |
Exemple de programmation 7
| 1 2 3 4 5 6 7 8 9 dix 11 12 13 | #inclure int main() int y, x = 5; y = x < 4 || x < 10; printf ("Résultat est:% d", y); |
Sortir
Explication
L'exemple de programmation ci-dessus est un autre exemple d'opérateur logique. Ici, l'expression donnée de l'opérateur logique est:
| 1 | y = x < 4 || x < 10 ; |
Ici || L'opérateur a combiné ces deux conditions. Instruction in ou opérateur, si les deux instructions sont fausses, alors seulement le résultat global = faux. Si une déclaration est «vraie», le résultat global est «vrai».
Dans ce programme, la première déclaration est «vraie» mais la 2ème déclaration est fausse. Donc, le résultat global est vrai. Ainsi, la sortie du résultat est 1.
Exemple de programmation 8
| 1 2 3 4 5 6 7 8 9 dix 11 12 13 | #inclure int main() int y, x = 10; y = x!= 10 || x> = 5; printf ("Résultat est:% d", y); |
Sortir
Explication
L'exemple de programmation ci-dessus est un autre exemple de logique et d'opérateur. Ici, l'expression donnée de l'opérateur logique est:
| 1 | y = x!= 10 || x> = 5; |
Ici, || L'opérateur a combiné ces deux conditions. Instruction in ou opérateur, si les deux instructions sont fausses, alors seulement le résultat global = faux. Si une déclaration est vraie, alors le résultat global est vrai.
Dans ce programme, la 1ère déclaration est fausse, mais la 2ème déclaration est vraie. Donc, le résultat global est vrai. Donc, le résultat est 1.
Conclusion
D'après la discussion ci-dessus sur les concepts des opérateurs logiques, nous sommes arrivés à la conclusion que les opérateurs logiques donnent au programmeur une variation de différents types de conditions qui sont appliquées dans le programme. Les opérateurs logiques rendent cette condition très facile à comprendre. Donc, cela augmente la lisibilité du programme.