Namespaces
Variants

Logical operators

From cppreference.net
C
C language
Expressions

Les opérateurs logiques appliquent des opérations d'algèbre booléenne standard à leurs opérandes.

Opérateur Nom de l'opérateur Exemple Résultat
! NON logique ! a la négation logique de a
&& ET logique a && b le ET logique de a et b
|| OU logique a || b le OU logique de a et b

Table des matières

NON logique

L'expression logique NOT a la forme

! expression

où

expression - une expression de tout type scalaire

L'opérateur logique NOT a pour type int . Sa valeur est ​ 0 ​ si expression s'évalue à une valeur comparée comme différente de zéro. Sa valeur est 1 si expression s'évalue à une valeur comparée comme égale à zéro. (donc ! E est équivalent à ( 0 == E ) )

Exécuter ce code 
#include <stdbool.h>
#include <stdio.h>
#include <ctype.h>
int main(void)
{
    bool b = !(2+2 == 4); // pas vrai
    printf("!(2+2==4) = %s\n", b ? "true" : "false");
    int n = isspace('a'); // non-zéro si 'a' est un espace, zéro sinon
    int x = !!n; // "bang-bang", idiome C courant pour mapper les entiers vers [0,1]
                 // (toutes les valeurs non nulles deviennent 1)
    char *a[2] = {"non-space", "space"};
    puts(a[x]); // maintenant x peut être utilisé en toute sécurité comme index pour un tableau de 2 chaînes
}

Sortie : 

!(2+2==4) = false
non-space

ET logique

L'expression logique ET a la forme

lhs && rhs

où

lhs - une expression de tout type scalaire
rhs - une expression de tout type scalaire, qui n'est évaluée que si lhs ne compare pas égal à ​ 0 ​

L'opérateur ET logique a pour type int et la valeur 1 si les deux opérandes lhs et rhs sont différents de zéro. Il a la valeur ​ 0 ​ dans le cas contraire (si l'un des deux opérandes lhs ou rhs ou les deux sont égaux à zéro).

Il y a un point de séquence après l'évaluation de lhs . Si le résultat de lhs est égal à zéro, alors rhs n'est pas évalué du tout (ce qu'on appelle l'évaluation court-circuit )

Exécuter ce code 
#include <stdbool.h>
#include <stdio.h>
int main(void)
{
    bool b = 2+2==4 && 2*2==4; // b == true
    1 > 2 && puts("this won't print");
    char *p = "abc";
    if(p && *p) // idiome courant en C : si p n'est pas nul
                // ET si p ne pointe pas vers la fin de la chaîne
    {           // (notez que grâce à l'évaluation en court-circuit,
                //  cela n'essaiera pas de déréférencer un pointeur nul)
    // ...      // ... alors effectuer un traitement de chaîne
    }
}

OU logique

L'expression logique OU a la forme

lhs || rhs

où

lhs - une expression de tout type scalaire
rhs - une expression de tout type scalaire, qui n'est évaluée que si lhs est égal à ​ 0 ​

L'opérateur logique-OU a le type int et la valeur 1 si soit lhs soit rhs est différent de zéro. Il a la valeur ​ 0 ​ dans le cas contraire (si à la fois lhs et rhs sont égaux à zéro).

Il y a un point de séquence après l'évaluation de lhs . Si le résultat de lhs compare inégal à zéro, alors rhs n'est pas évalué du tout (ce qu'on appelle l'évaluation court-circuit )

Exécuter ce code 
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>
int main(void)
{
    bool b = 2+2 == 4 || 2+2 == 5; // true
    printf("true or false = %s\n", b ? "true" : "false");
    // logical OR can be used simialar to perl's "or die", as long as rhs has scalar type
    fopen("test.txt", "r") || printf("could not open test.txt: %s\n", strerror(errno));
}

Sortie possible : 

true or false = true
could not open test.txt: No such file or directory

Références

  • Norme C11 (ISO/CEI 9899:2011) :
  • 6.5.3.3 Opérateurs arithmétiques unaires (p: 89)
  • 6.5.13 Opérateur ET logique (p: 99)
  • 6.5.14 Opérateur OU logique (p: 99)
  • Norme C99 (ISO/CEI 9899:1999) :
  • 6.5.3.3 Opérateurs arithmétiques unaires (p: 79)
  • 6.5.13 Opérateur ET logique (p: 89)
  • 6.5.14 Opérateur OU logique (p: 89)
  • Norme C89/C90 (ISO/CEI 9899:1990) :
  • 3.3.3.3 Opérateurs arithmétiques unaires
  • 3.3.13 Opérateur ET logique
  • 3.3.14 Opérateur OU logique

Voir aussi

Priorité des opérateurs

Opérateurs courants
affectation incrémentation
décrémentation 		arithmétique logique comparaison accès aux
membres 		autres

a = b
a + = b
a - = b
a * = b
a / = b
a % = b
a & = b
a | = b
a ^ = b
a <<= b
a >>= b

++ a
-- a
a ++
a --

+ a
- a
a + b
a - b
a * b
a / b
a % b
~a
a & b
a | b
a ^ b
a << b
a >> b

! a
a && b
a || b

a == b
a ! = b
a < b
a > b
a <= b
a >= b

a [ b ]
* a
& a
a - > b
a. b

a ( ... )
a, b
( type ) a
a ? b : c
sizeof

_Alignof
(depuis C11)
(jusqu'à C23)

alignof
(depuis C23)

Voir également

Documentation C++ pour Opérateurs logiques