Espaces de noms
Variantes
Affichages
Actions

Logical operators

De cppreference.com
< cpp‎ | language

 
 
Langage C++
Sujets généraux
Contrôle de flux
Instructions conditionnelles
Instructions d'itération
Instructions de saut
Fonctions
déclaration de fonction
expression lambda
fonction générique
spécificateur inline
spécification d'exception (obsolète)
spécificateur noexcept (C++11)
Exceptions
Espaces de noms
Types
spécificateur decltype (C++11)
Qualificatifs
qualificatifs const et volatile
qualificatifs de stockage
qualificatif constexpr (C++11)
qualificatif auto (C++11)
qualificatif alignas (C++11)
Initialisation
Littéraux
Expressions
opérateurs alternatifs
Utilitaires
Types
déclaration typedef
déclaration d'alias de type (C++11)
attributs (C++11)
Jette
Original:
Casts
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
conversions implicites
conversion const_cast
conversion static_cast
conversion dynamic_cast
conversion reinterpret_cast
conversions style C et style fonction
Allocation de mémoire
Classes
Qualificatifs spécifiques aux membres de classe
Fonctions membres spéciales
Modèles
classes génériques
fonctions génériques
spécialisation de modèles
paquets de paramètres (C++11)
Divers
Assembleur
 
Retourne le résultat d'une opération booléenne .
Original:
Returns the result of a boolean operation.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Operator name Syntax Over​load​able Prototype examples (for class T)
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.

Sommaire

[modifier] 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 .
Original:
The logical operators apply logic functions (NOT, AND, and inclusive OR) to boolean arguments (or types contextually-convertible to bool), with a boolean result. Unlike the opérateurs logiques bit à bit, these operators (in their built-in form) do not evaluate the second operand if the result is known after evaluating the first.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Opérateurs intégrés

Les signatures suivantes fonction intégrée de participer à la résolution de surcharge:
Original:
The following built-in function signatures participate in overload resolution:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
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 .
Original:
If the operand is not bool, it is converted to bool using conversion contextuelle bool: it is only well-formed if the declaration bool t(arg) is well-formed, for some invented temporary t.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
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 .
Original:
For the built-in logical NOT operator, the result is true if the operand is false. Otherwise, the result is false.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
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é .
Original:
For the built-in logical AND operator, the result is true if both operands are true. Otherwise, the result is false. If the first operand is false, the second operand is not evaluated.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
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é .
Original:
For the built-in logical OR operator, the result is true if either the first or the second operand (or both) is true. If the firstoperand is true, the second operand is not evaluated.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Résultats

a true false
!a false true
and a
true false
b true true false
false false false
or a
true false
b true true true
false true false

[modifier] 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

[modifier] 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:
Original:
Because the short-circuiting properties of operator&& and operator|| do not apply to overloads, and because types with boolean semantics are uncommon, only two standard library classes overload these operators:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
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)
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)
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]

[modifier] 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)