Espaces de noms
Variantes
Affichages
Actions

Comparison 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
 
Compare les arguments .
Original:
Compares the arguments.
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
equal to a == b Yes bool T::operator ==(const T2 &b) const; bool operator ==(const T &a, const T2 &b);
not equal to a != b Yes bool T::operator !=(const T2 &b) const; bool operator !=(const T &a, const T2 &b);
less than a < b Yes bool T::operator <(const T2 &b) const; bool operator <(const T &a, const T2 &b);
greater than a > b Yes bool T::operator >(const T2 &b) const; bool operator >(const T &a, const T2 &b);
less than or equal to a <= b Yes bool T::operator <=(const T2 &b) const; bool operator <=(const T &a, const T2 &b);
greater than or equal to 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.
  • 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.
  • T2 peuvent être de tout type, y compris T
    Original:
    T2 can be any type including T
    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

Retourne le résultat booléen de la comparaison des valeurs des arguments qui ne sont pas modifiés .
Original:
Returns the boolean result of comparison of the values of the arguments, which are not modified.
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 arithmétiques

Pour chaque paire de types arithmétiques promus L et R, y compris les types d'énumération, les signatures de fonction suivants participent à la résolution de surcharge:
Original:
For every pair of promoted arithmetic types L and R, including enumeration types, the following 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<(L, R);
bool operator>(L, R);
bool operator<=(L, R);
bool operator>=(L, R);
bool operator==(L, R);
bool operator!=(L, R);
Si les opérandes a arithmétique ou une énumération de type (scope ou sans portée), les conversions arithmétiques usuelles' sont effectués suivant les règles de opérateurs arithmétiques. Les valeurs sont comparées après conversion:
Original:
If the operands has arithmetic or enumeration type (scoped or unscoped), usual arithmetic conversions are performed following the rules for opérateurs arithmétiques. The values are compared after conversions:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Exemple

#include <iostream>
int main()
{
    std::cout << std::boolalpha;
    int n = -1;
 
    int n2 = 1;
    std::cout << " -1 == 1? " << (n == n2) << '\n'
              << "Comparing two signed values:\n"
              << " -1  < 1? " << (n < n2) << '\n'
              << " -1  > 1? " << (n > n2) << '\n';
 
    unsigned int u = 1;
    std::cout << "Comparing signed and unsigned:\n"
              << " -1  < 1? " << (n < u) << '\n'
              << " -1  > 1? " << (n > u) << '\n';
 
    unsigned char uc = 1;
    std::cout << "Comparing signed and smaller unsigned:\n"
              << " -1  < 1? " << (n < uc) << '\n'
              << " -1  > 1? " << (n > uc) << '\n';
}

Résultat :

-1 == 1? false
Comparing two signed values:
 -1  < 1? true
 -1  > 1? false
Comparing signed and unsigned:
 -1  < 1? false
 -1  > 1? true
Comparing signed and smaller unsigned:
 -1  < 1? true
 -1  > 1? false

[modifier] Les opérateurs de comparaison de pointeurs

Pour chaque type de P qui est soit pointeur à l'objet ou au pointeur de fonction ou std::nullptr_t, et pour chaque type de MP qui est un pointeur vers l'objet membre ou un pointeur vers une fonction membre, les signatures de fonction suivants participent à la résolution de surcharge:
Original:
For every type P which is either pointer to object or pointer to function or std::nullptr_t, and for every type MP that is a pointer to member object or pointer to member function, the following 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<(P, P);
bool operator>(P, P);
bool operator<=(P, P);
bool operator>=(P, P);
bool operator==(P, P);
bool operator!=(P, P);
bool operator==(MP, MP);
bool operator!=(MP, MP);
Les opérateurs de comparaison peuvent être utilisés pour comparer deux pointeurs (ou pointeurs-vers-membres, pour operator== et operator!= uniquement) ou un pointeur et un pointeur NULL constante, ou deux constantes pointeur nul (mais seulement dans la mesure où au moins l'un d'entre eux est std::nullptr_t: comparaison de NULL et NULL suit des règles arithmétiques). Conversions de pointeurs (pointeur vers conversions membres si les arguments sont des pointeurs vers des membres) et conversions de qualification sont appliquées aux deux opérandes afin d'obtenir l composite de type pointeur, comme suit
Original:
Comparison operators can be used to compare two pointers (or pointers-to-members, for operator== and operator!= only), or a pointer and a null pointer constant, or two null pointer constants (but only as long as at least one of them is std::nullptr_t: comparison of NULL and NULL follows arithmetic comparison rules). Conversions de pointeurs (pointer to member conversions if the arguments are pointers to members) and conversions de qualification are applied to both operands to obtain the composite pointer type, as follows
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
Si les deux opérandes sont des constantes pointeur NULL, le type de pointeur composite est std::nullptr_t
Original:
If both operands are null pointer constants, the composite pointer type is std::nullptr_t
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
Si une opérande d'une constante de pointeur nul et l'autre est un pointeur, du type composite, c'est exactement le type de pointeur
Original:
If one operand a null pointer constant and the other is a pointer, the composite type is exactly the pointer type
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3)
Si les deux opérandes sont des pointeurs vers le même type, avec différents cv-qualification, le composite est un pointeur vers le même type de cv-qualification qui est une union de la CV-qualification des arguments .
Original:
If both operands are pointers to the same type, with different cv-qualification, the composite is pointer to the same type with cv-qualification that is a union of the cv-qualifications of the arguments.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Notez que cela implique que n'importe quel pointeur peut être comparé à void* .
Original:
Note that this implies that any pointer can be compared with void*.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Les résultats de la comparaison de deux pointeurs (après conversion) sont déterminés comme suit:
Original:
Results of comparing two pointers (after conversions) are determined as follows:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
Si les pointeurs p et q
Original:
If the pointers p and q
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
a)
pointer vers le même objet ou d'une fonction
Original:
point to the same object or function
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
b)
ou pointer un après la fin de la même matrice
Original:
or point one past the end of the same array
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
c)
ou sont tous les deux pointeurs nuls
Original:
or are both null pointers
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
alors les pointeurs' sont égales: p==q, p<=q et p>=q retour true, tandis que p!=q, p<q et p>q retour false,
Original:
then the pointers compare equal: p==q, p<=q, and p>=q return true, while p!=q, p<q, and p>q return false,
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
Si l'un des opérandes est un pointeur nul et l'autre non, ils comparent inégale: p==q retours true, p!=q retours false, le comportement des autres opérateurs n'est pas spécifié .
Original:
If one of the operands is a null pointer and the other is not, they compare unequal: p==q returns true, p!=q returns false, the behavior of other operators is unspecified.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3)
Si les pointeurs p et q point à des membres de la même matrice ou a[i] a[j] et une delà de l'extrémité de la rangée, ils sont comparés aux résultats de pointeurs est le même que le résultat de la comparaison des indices: si i<j==true puis {{{1}}} .
Original:
If the pointers p and q point to members of the same array a[i] and a[j] or one past the end of the array, they results of comparing the pointers is the same as the result of comparing the indexes: if i<j==true then {{{1}}}.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
4)
Si les pointeurs p et q point de non-membres de données statiques au sein de la même catégorie ou sous-objets de base différentes dans la même classe dérivée, ou à leurs membres ou sous-objets, de manière récursive, et si les membres pointés / sous-objets ont le même contrôle d'accès (par exemple, à la fois public:), et la classe n'est pas un syndicat, alors le pointeur sur le sous-objet par la suite déclaré / membre supérieur compare le pointeur sur le sous-objet précédemment déclarées / membre. En d'autres termes, les membres du groupe dans chacun des trois modes d'accès sont placées en mémoire dans l'ordre de déclaration .
Original:
If the pointers p and q point to non-static data members within the same class or different base subobjects within the same derived class, or to their members or subobjects, recursively, and if the pointed-to members/subobjects have the same access control (e.g. both public:), and the class is not a union, then the pointer to the later declared subobject/member compares greater than the pointer to the earlier declared subobject/member. In other words, class members in each of the three access modes are positioned in memory in order of declaration.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
6)
Si les pointeurs p et le point q aux membres de la union même, elles sont égales (typiquement une conversion explicite pour void* est requis pour l'un des opérandes)
Original:
If the pointers p and q point to members of the same union, they compare equal (typically an explicit conversion to void* is required for one of the operands)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
7)
Si l'un des pointeurs est un pointeur vers void et les deux pointeurs pointent à la même adresse ou les deux sont des pointeurs nuls, ils comparent l'égalité .
Original:
If one of the pointers is a pointer to void and both pointers point to the same address or are both null pointers, they compare equal.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
8)
Si deux constantes pointeur nul, on constate qu'ils sont équivalentes .
Original:
If two null pointer constants are compared, they compare equal.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
9)
Si les deux opérandes sont des pointeurs vers membre (objet ou la fonction), elles sont égales si elles soulignent toutes deux le même membre de la classe la plus dérivée .
Original:
If both operands are pointers to member (object or function), they compare equal if they both point to the same member of the most derived class.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
10)
Dans le cas contraire (si les pointeurs pointer vers des objets dans des tableaux différents, ou à des fonctions différentes, ou aux membres de certains objets avec contrôle d'accès différent, etc), les résultats de p<q, p>q, p<=q et p>=q ne sont pas précisés, et p!=q retours false.
Original:
Otherwise (if the pointers point to objects in different arrays, or to different functions, or to members of some object with different access control, etc), the results of p<q, p>q, p<=q, and p>=q are unspecified, and p!=q returns false.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Exemple

#include <iostream>
struct Foo  { int n1; int n2; };
union Union { int n; double d; };
int main()
{
    std::cout << std::boolalpha;
 
    char a[4] = "abc";
 
    char* p1 = &a[1];
    char* p2 = &a[2];
    std::cout << "Pointers to array elements: p1 == p2 " << (p1 == p2)
              << ", p1 < p2 "  << (p1 < p2) << '\n';
 
    Foo f;
    int* p3 = &f.n1;
    int* p4 = &f.n2;
    std::cout << "Pointers to members of a class: p3 == p4 " << (p3 == p4)
              << ", p3 < p4 "  << (p3 < p4) << '\n';
 
    Union u;
    int* p5 = &u.n;
    double* p6 = &u.d;
    std::cout << "Pointers to members of a union: p5 == (void*)p6 " << (p5 == (void*)p6)
              << ", p5 < p6 "  << (p5 < (void*)p6) << '\n';
}

Résultat :

Pointers to array elements: p1 == p2 false, p1 < p2 true
Pointers to members of a class: p3 == p4 false, p3 < p4 true
Pointers to members of a union: p5 == (void*)p6 true, p5 < p6 false

[modifier] Notes

Parce que ce groupe les opérateurs de gauche à droite, le a<b<c expression est analysée (a<b)<c, et non a<(b<c) ou (a<b)&&(b<c) .
Original:
Because these operators group left-to-right, the expression a<b<c is parsed (a<b)<c, and not a<(b<c) or (a<b)&&(b<c).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Une exigence commune définie par l'utilisateur pour operator< est strict ordonnancement faible. En particulier, cela est requis par les algorithmes standards et des conteneurs qui travaillent avec des types LessThanComparable: std::sort, std::max_element, std::map, etc
Original:
A common requirement for user-defined operator< is strict ordonnancement faible. In particular, this is required by the standard algorithms and containers that work with LessThanComparable types: std::sort, std::max_element, std::map, etc.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Bien que les résultats de la comparaison des pointeurs d'origine aléatoire (par exemple, pas tout en montrant les membres du même réseau) n'est pas spécifié, de nombreuses implémentations fournissent totale ordre strict de pointeurs, par exemple, si elles sont appliquées comme des adresses au sein de l'espace d'adressage virtuel continue. Ces implémentations qui ne sont pas (par exemple, où tous les bits du pointeur font partie d'une adresse mémoire et doivent être ignorées pour la comparaison, ou un calcul supplémentaire est nécessaire ou non pointeur et un entier n'est pas une relation 1 à 1), fournissent un spécialisation des std::less pour les pointeurs qui a cette garantie. Cela permet d'utiliser tous les pointeurs d'origine aléatoire comme clés dans des conteneurs standards associatifs tels que std::set ou std::map .
Original:
Although the results of comparing pointers of random origin (e.g. not all pointing to members of the same array) is unspecified, many implementations provide totale ordre strict of pointers, e.g. if they are implemented as addresses within continuous virtual address space. Those implementations that do not (e.g. where not all bits of the pointer are part of a memory address and have to be ignored for comparison, or an additional calculation is required or otherwise pointer and integer is not a 1 to 1 relationship), provide a specialization of std::less for pointers that has that guarantee. This makes it possible to use all pointers of random origin as keys in standard associative containers such as std::set or std::map.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Bibliothèque standard

Les opérateurs de comparaison sont surchargées pour de nombreuses classes dans la bibliothèque standard .
Original:
Comparison operators are overloaded for many classes in the standard library.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
checks whether the objects refer to the same type
(fonction membre publique de std::type_info) [edit]
compare deux error_codes
Original:
compares two error_codes
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction)
compare error_conditions et error_codes
Original:
compares error_conditions and error_codes
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction)
compare lexicographiquement les valeurs de la paire
Original:
lexicographically compares the values in the pair
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) [edit]
compare lexicographiquement les valeurs dans le tuple
Original:
lexicographically compares the values in the tuple
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) [edit]
compare le contenu
Original:
compares the contents
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::bitset) [edit]
compare deux instances du programme d'allocation
Original:
compares two allocator instances
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::allocator) [edit]
compare à un autre ou avec unique_ptr nullptr
Original:
compares to another unique_ptr or with nullptr
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) [edit]
compare avec un autre ou avec shared_ptr nullptr
Original:
compares with another shared_ptr or with nullptr
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) [edit]
compare avec une std::function std::nullptr
Original:
compares an std::function with std::nullptr
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)
compare deux durées
Original:
compares two durations
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)
compare deux points dans le temps
Original:
compares two time points
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)
compare deux instances scoped_allocator_adaptor
Original:
compares two scoped_allocator_adaptor instances
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::scoped_allocator_adaptor) [edit]
compare les objets sous-jacents std::type_info
Original:
compares the underlying std::type_info objects
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::type_index) [edit]
compare lexicographiquement deux chaînes
Original:
lexicographically compares two strings
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) [edit]
comparaison d'égalité entre les objets locale
Original:
equality comparison between locale objects
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::locale) [edit]
compare lexicographiquement les valeurs dans le array
Original:
lexicographically compares the values in the array
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) [edit]
compare lexicographiquement les valeurs dans le deque
Original:
lexicographically compares the values in the deque
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) [edit]
compare lexicographiquement les valeurs dans le forward_list
Original:
lexicographically compares the values in the forward_list
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) [edit]
compare lexicographiquement les valeurs dans le list
Original:
lexicographically compares the values in the list
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) [edit]
compare lexicographiquement les valeurs dans le vector
Original:
lexicographically compares the values in the vector
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) [edit]
compare lexicographiquement les valeurs dans le map
Original:
lexicographically compares the values in the map
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) [edit]
compare lexicographiquement les valeurs dans le multimap
Original:
lexicographically compares the values in the multimap
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) [edit]
compare lexicographiquement les valeurs dans le set
Original:
lexicographically compares the values in the set
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) [edit]
compare lexicographiquement les valeurs dans le multiset
Original:
lexicographically compares the values in the multiset
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) [edit]
compare les valeurs de la unordered_map
Original:
compares the values in the unordered_map
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) [edit]
compare les valeurs de la unordered_multimap
Original:
compares the values in the unordered_multimap
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) [edit]
compare les valeurs de la unordered_set
Original:
compares the values in the unordered_set
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) [edit]
compare les valeurs de la unordered_multiset
Original:
compares the values in the unordered_multiset
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) [edit]
compare lexicographiquement les valeurs dans le queue
Original:
lexicographically compares the values in the queue
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) [edit]
compare lexicographiquement les valeurs dans le stack
Original:
lexicographically compares the values in the stack
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) [edit]
compare deux reverse_iterators pour l'égalité
Original:
compares two reverse_iterators for equality
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)
reverse_iterators commandes
Original:
orders reverse_iterators
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)
compare deux move_iterators
Original:
compares two move_iterators
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)
compare deux istream_iterators
Original:
compares two istream_iterators
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)
compare deux istreambuf_iterators
Original:
compares two istreambuf_iterators
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)
compare deux nombres complexes ou un complexe et un scalaire
Original:
compares two complex numbers or a complex and a scalar
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) [edit]
compare deux valarrays ou un valarray avec une valeur
Original:
compares two valarrays or a valarray with 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) [edit]
compare les états internes des deux moteurs de nombres pseudo-aléatoires
Original:
compares the internal states of two pseudo-random number engines
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction) [edit]
compare deux objets de distribution
Original:
compares two distribution objects
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction) [edit]
compare les valeurs lexicographiquement dans le récipient
Original:
lexicographically compares the values in the container
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction) [edit]
compare lexicographiquement les valeurs dans le résultat deux match
Original:
lexicographically compares the values in the two match result
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)
compare deux regex_iterators
Original:
compares two regex_iterators
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)
compare deux regex_token_iterators
Original:
compares two regex_token_iterators
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)
compare deux objets thread::id
Original:
compares two thread::id objects
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction)
automatically generates comparison operators based on user-defined operator== and operator<
(fonction générique) [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)