Namespaces
Variants

Logical operators

From cppreference.net
C++
C++ language
General topics
Flow control
Conditional execution statements
Iteration statements (loops)
Jump statements
Functions
Function declaration
Lambda function expression
inline specifier
Dynamic exception specifications ( until C++17* )
noexcept specifier (C++11)
Exceptions
Namespaces
Types
Specifiers
constexpr (C++11)
consteval (C++20)
constinit (C++20)
Storage duration specifiers
Initialization
Expressions
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Memory allocation
Classes
Class-specific function properties
Special member functions
Templates
Miscellaneous
Expressions
General
Literals
Operators
Conversions

Retourne le résultat d'une opération booléenne.

Nom de l'opérateur Syntaxe Surchargeable Exemples de prototypes (pour class T )
Définition interne à la classe Définition externe à la classe
Négation not a

! a

Oui bool T :: operator ! ( ) const ; bool operator ! ( const T & a ) ;
ET a and b

a && b

Oui bool T :: operator && ( const T2 & b ) const ; bool operator && ( const T & a, const T2 & b ) ;
OU inclusif a or b

a || b

Oui bool T :: operator || ( const T2 & b ) const ; bool operator || ( const T & a, const T2 & b ) ;
Notes
  • Les formes de type mot-clé ( and , or , not ) et les formes symboliques ( && , || , ! ) peuvent être utilisées de manière interchangeable (voir représentations alternatives ).
  • Tous les opérateurs intégrés retournent bool , et la plupart des surcharges définies par l'utilisateur retournent également bool afin que les opérateurs définis par l'utilisateur puissent être utilisés de la même manière que les opérateurs intégrés. Cependant, dans une surcharge d'opérateur définie par l'utilisateur, n'importe quel type peut être utilisé comme type de retour (y compris void ).
  • Les opérateurs intégrés && et || effectuent une évaluation en court-circuit (n'évaluent pas le second opérande si le résultat est connu après l'évaluation du premier), mais les opérateurs surchargés se comportent comme des appels de fonction réguliers et évaluent toujours les deux opérandes.

Table des matières

Explication

Les expressions d'opérateurs logiques ont la forme

! rhs (1)
lhs && rhs (2)
lhs || rhs (3)
1) NON logique
2) ET logique
3) OU logique inclusif

Si l'opérande n'est pas bool , il est converti en bool en utilisant la conversion contextuelle en bool : cela n'est valide que si la déclaration bool t(arg) est valide, pour un t temporaire inventé.

Le résultat est une bool prvalue.

Pour l'opérateur logique NON intégré, le résultat est true si l'opérande est false . Sinon, le résultat est false .

Pour l'opérateur logique ET intégré, le résultat est true si les deux opérandes sont true . Sinon, le résultat est false . Cet opérateur utilise l'évaluation court-circuit : si le premier opérande est false , le second opérande n'est pas évalué.

Pour l'opérateur logique OR intégré, le résultat est true si le premier ou le second opérande (ou les deux) est true . Cet opérateur est à court-circuit : si le premier opérande est true , le second opérande n'est pas évalué.

Notez que les opérateurs logiques bit à bit n'effectuent pas d'évaluation court-circuit.

Résultats

a true false
! a false true
**Note:** Aucune traduction n'a été effectuée car : - Tous les termes textuels se trouvent dans des balises ` ` qui sont considérées comme du code C++ - Les mots "true", "false" et "!" sont des termes spécifiques au C++ - La variable "a" fait partie du code C++ Le contenu respecte donc toutes les contraintes de non-traduction spécifiées.
and a
true false
b true true false
false false false
or a
true false
b true true true
false true false
**Note:** Aucune traduction n'a été effectuée car : 1. Tous les textes se trouvent dans des balises ` ` (équivalent à ` ` pour le code C++) 2. Les termes C++ (`or`, `true`, `false`, `a`, `b`) ne doivent pas être traduits 3. La structure HTML et les attributs sont conservés intacts

Dans le cadre de la résolution de surcharge pour les opérateurs définis par l'utilisateur , les signatures de fonctions intégrées suivantes participent à la résolution de surcharge :

bool operator ! ( bool )
bool operator && ( bool , bool )
bool operator || ( bool , bool )
**Note:** Le contenu HTML fourni ne contient aucun texte à traduire en dehors des balises ` `, ` 
` et ``. Tous les éléments visibles sont soit du code C++ (préservé selon les instructions), soit des balises HTML et attributs (également préservés).

Exemple

Exécuter ce code 
#include <iostream>
#include <sstream>
#include <string>
int main()
{
    int n = 2;
    int* p = &n;
    // les pointeurs sont convertibles en bool
    if (    p && *p == 2  // "*p" peut être utilisé sans risque après "p &&"
        || !p &&  n != 2) // || a une précédence inférieure à &&
        std::cout << "true\n";
    // les flux sont également convertibles en bool
    std::stringstream cin;
    cin << "3...\n" << "2...\n" << "1...\n" << "quit";
    std::cout << "Entrez 'quit' pour quitter.\n";
    for (std::string line;    std::cout << "> "
                           && std::getline(cin, line)
                           && line != "quit";)
        std::cout << line << '\n';
}

Sortie : 

true
Entrez 'quit' pour quitter.
> 3...
> 2...
> 1...
>

Bibliothèque standard

En raison du fait que les propriétés de court-circuit de operator&& et operator|| ne s'appliquent pas aux surcharges, et parce que les types avec une sémantique booléenne sont rares, seules deux classes de la bibliothèque standard surchargent ces opérateurs :

applique un opérateur arithmétique unaire à chaque élément du valarray
(fonction membre publique de std::valarray<T> )
applique des opérateurs binaires à chaque élément de deux valarrays, ou d'un valarray et d'une valeur
(fonction template)
vérifie si une erreur s'est produite (synonyme de fail() )
(fonction membre publique de std::basic_ios<CharT,Traits> )

Voir aussi

Priorité des opérateurs

Surcharge d'opérateur

objet fonction implémentant x && y
(modèle de classe)
objet fonction implémentant x || y
(modèle de classe)
objet fonction implémentant ! x
(modèle de classe)
Opérateurs courants
affectation incrémentation
décrémentation 		arithmétique logique comparaison accès
membre 		autre

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
a - > b
a. b
a - > * b
a. * b

appel de fonction

a ( ... )
virgule

a, b
conditionnel

a ? b : c
Opérateurs spéciaux

static_cast convertit un type en un autre type apparenté
dynamic_cast convertit au sein des hiérarchies d'héritage
const_cast ajoute ou supprime les cv -qualificateurs
reinterpret_cast convertit un type en un type non apparenté
C-style cast convertit un type en un autre par un mélange de static_cast , const_cast , et reinterpret_cast
new crée des objets avec une durée de stockage dynamique
delete détruit les objets précédemment créés par l'expression new et libère la zone mémoire obtenue
sizeof interroge la taille d'un type
sizeof... interroge la taille d'un pack (depuis C++11)
typeid interroge les informations de type d'un type
noexcept vérifie si une expression peut lever une exception (depuis C++11)
alignof interroge les exigences d'alignement d'un type (depuis C++11)

Documentation C pour Opérateurs logiques