Logical operators

This page has been machine-translated from the English version of the wiki using Google Translate.

The translation may contain errors and awkward wording. Hover over text to see the original version. You can help to fix errors and improve the translation. For instructions click here.

Click here for the English version of this page

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

Operator name	Syntax	Overloadable	Prototype examples (for `class T`)
Operator name	Syntax	Overloadable	Inside class definition	Outside class definition
negation	`not a` `!a`	Yes	`bool T::operator!() const;`	`bool operator!(const T &a);`
AND	`a and b` `a && b`	Yes	`bool T::operator&&(const T2 &b) const;`	`bool operator&&(const T &a, const T2 &b);`
inclusive OR	`a or b` `a \|\| b`	Yes	`bool T::operator\|\|(const T2 &b) const;`	`bool operator\|\|(const T &a, const T2 &b);`
'Note' Original: Notes The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. Les formes mots clés comme (`and`, `or`, `not`) et les formes de symboles comme (`&&`, `\|\|`, `!`) peuvent être utilisés de façon interchangeable (Voir représentations alternatives) Original: The keyword-like forms (`and`,`or`,`not`) and the symbol-like forms (`&&`,`\|\|`,`!`) can be used interchangeably (See représentations alternatives) The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. Tout retour intégré opérateurs `bool`, et la plupart définies par l'utilisateur surcharges également revenir `bool` de sorte que les opérateurs définis par l'utilisateur peut être utilisé de la même manière que le haut-ins. Cependant, définie par l'utilisateur surcharge d'opérateur, n'importe quel type peut être utilisé comme type de retour (y compris `void`) . Original: All built-in operators return `bool`, and most user-defined overloads also return `bool` so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including `void`). The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. Opérateurs Builtin `&&` et `\|\|` effectuer un court-circuit d'évaluation (ne pas évaluer le second opérande, si le résultat est connu après une évaluation de la première), mais se comportent comme des opérateurs surchargés appels de fonctions régulières et toujours évaluer les deux opérandes Original: Builtin operators `&&` and `\|\|` perform short-circuit evaluation (do not evaluate the second operand if the result is known after evaluating the first), but overloaded operators behave like regular function calls and always evaluate both operands The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions.

Explication

Les opérateurs logiques s'appliquent fonctions logiques (NOT, AND, OR et inclusive) aux arguments booléens (ou types contexte convertibles à bool), avec un résultat booléen. Contrairement à la opérateurs logiques bit à bit, ces opérateurs (dans leur formulaire intégré) n'évaluent pas le second opérande, si le résultat est connu après une évaluation de la première .

Opérateurs intégrés

Les signatures suivantes fonction intégrée de participer à la résolution de surcharge:

`bool operator!(bool)`
`bool operator&&(bool, bool)`
`bool operator\|\|(bool, bool)`

Si l'opérande n'est pas bool, il est converti en utilisant bool conversion contextuelle bool: ce n'est que bien formée si la déclaration bool t(arg) est bien formée, pour certains t inventé temporaire .

Pour le haut-opérateur logique NOT, le résultat est true si l'opérande est false. Dans le cas contraire, le résultat est false .

Pour le haut-opérateur AND logique, le résultat est true si les deux opérandes sont true. Dans le cas contraire, le résultat est false. Si le premier opérande est false, le second opérande n'est pas évalué .

Pour le haut-opérateur logique OU, le résultat est true si le premier ou le deuxième opérande (ou les deux) est true. Si le firstoperand est true, le second opérande n'est pas évalué .

Résultats

`a`	`true`	`false`
`!a`	`false`	`true`

`and`		`a`
`and`		`true`	`false`
`b`	`true`	`true`	`false`
`b`	`false`	`false`	`false`

`or`		`a`
`or`		`true`	`false`
`b`	`true`	`true`	`true`
`b`	`false`	`true`	`false`

Exemple

#include <iostream>
#include <string>
int main()
{
    int n = 2;
    int* p = &n;
    // pointers are convertible to bool
    if(    p && *p == 2   // "*p" is safe to use after "p &&"
       || !p &&  n != 2 ) // || has lower precedence than &&
        std::cout << "true\n";

    // streams are also convertible to bool
    std::cout << "Enter 'quit' to quit.\n";
    for(std::string line;    std::cout << "> "
                          && std::getline(std::cin, line)
                          && line != "quit"; )
        ;
}

Résultat :

true
Enter 'quit' to quit.
> test
> quit

Bibliothèque standard

Comme les propriétés de court-circuit de operator&& et operator|| ne s'appliquent pas aux surcharges, et parce que les types booléens avec la sémantique sont rares, seulement deux classes de la bibliothèque standard surcharger ces opérateurs:


operator!	applique un opérateur arithmétique unaire pour chaque élément de la valarray Original: applies a unary arithmetic operator to each element of the valarray The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction membre publique de `std::valarray`)

operator&& operator\|\|	des opérateurs binaires s'applique à chaque élément de valarrays deux, ou un valarray et une valeur Original: applies binary operators to each element of two valarrays, or a valarray and a value The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction générique)

operator!	vérifie si une erreur s'est produite (synonyme de `fail()`) Original: checks if an error has occurred (synonym of `fail()`) The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (fonction membre publique de `std::basic_ios`) [edit]

Voir aussi

La priorité des opérateurs

Opérateurs ordinaires
affectation	incrémentation décrémentation	arithmétique	logique	comparaison	accès aux membre	autre
`a = b a = rvalue 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->b a.*b`	`a(...) a, b (type) a ? :`
Opérateurs spéciaux
`static_cast` convertit un type dans un autre type compatible `dynamic_cast` convertit une classe de base virtuelle dans une classe dérivée `const_cast` convertit un type dans un type compatible avec des cv-qualifiers différents `reinterpret_cast` convertit un type dans un type incompatibles `new` allocation de la mémoire `delete` libère de la mémoire `sizeof` récupère la taille d'un type `sizeof...` récupère la taille d'un paquet de paramètres (depuis C++11) `typeid` récupère les informations de type d'un type `noexcept` vérifie si une expression peut lancer une exception (depuis C++11) `alignof` récupère les conditions d'alignement d'un type (depuis C++11)

Langage
Concepts
Bibliothèque d'utilitaires
Bibliothèque pour les chaînes de caractères
Bibliothèque de conteneurs
Bibliothèque d'algorithmes
Bibliothèque d'itérateurs
Bibliothèque pour le calcul numérique
Bibliothèque pour les entrées/sorties
Bibliothèque pour la régionalisation
Bibliothèque pour les expressions régulières (C++11)
Bibliothèque pour les opérations atomiques (C++11)
Bibliothèque pour les processus légers (threads) (C++11)

cppreference.com

Rechercher

Espaces de noms

Variantes

Affichages

Actions