Espaces de noms
Variantes
Affichages
Actions

Other 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
 
Operator name Syntax Over​load​able Prototype examples (for class T)
Inside class definition Outside class definition
function call a(a1, a2) Yes R T::operator()(Arg1 &a1, Arg2 &a2, ... ...); N/A
comma a, b Yes T2& T::operator,(T2 &b); T2& operator,(const T &a, T2 &b);
conversion (type) a Yes operator type() N/A
ternary conditional a ? b : c No N/A N/A

Sommaire

[modifier] Explication

Appel de la fonction' opérateur fournit une sémantique de fonction pour n'importe quel objet .
Original:
function call operator provides function semantics for any object.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
' Opérateur de conversion convertit les données de type à un autre type. Le nom de l'opérateur doit être le même que le type destiné à être retourné .
Original:
conversion operator converts given type to another type. The name of the operator must be the same as the type intended to be returned.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Ternaire' opérateur conditionnel vérifie la valeur booléenne de la première expression et remplace toute clause opérateur avec la deuxième ou la troisième expression en fonction de la valeur résultante .
Original:
ternary conditional operator checks the boolean value of the first expression and replaces entire operator clause with the second or the third expression depending on the resulting value.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] Built-in opérateur d'appel de fonction

Une expression d'appel de fonction, comme E(A1, A2, A3), consiste en une expression qui désigne la fonction, E, suivie d'une liste éventuellement vide de A1, A2, A3, ... expressions entre parenthèses .
Original:
A function call expression, such as E(A1, A2, A3), consists of an expression that names the function, E, followed by a possibly empty list of expressions A1, A2, A3, ..., in parentheses.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
L'expression qui désigne la fonction peut être
Original:
The expression that names the function can be
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
a)
lvalue expression qui se réfère à une fonction
Original:
lvalue expression that refers to a function
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
b)
pointeur de fonction
Original:
pointer to function
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
c)
expression explicite classe d'accès membre qui sélectionne une fonction membre
Original:
explicit classe d'accès membre expression that selects a member function
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
d)
implicite expression accès membre de classe, par exemple nom de la fonction membre utilisé dans une autre fonction membre .
Original:
implicit class member access expression, e.g. member function name used within another member function.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
La fonction (ou membre) nom spécifié par E peuvent être surchargés, résolution de surcharge règles utilisées pour déterminer les surcharges doit être appelé .
Original:
The function (or member) name specified by E can be overloaded, résolution de surcharge rules used to decide which overload is to be called.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Si E spécifie une fonction membre, il peut être virtuel, auquel cas la crosse final de cette fonction sera appelée, à l'aide de dispatch dynamique lors de l'exécution .
Original:
If E specifies a member function, it may be virtual, in which case the final overrider of that function will be called, using dynamic dispatch at runtime.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Pour appeler la fonction, toutes les expressions A1, A2, A3, etc, à condition que les arguments sont évalués dans un ordre arbitraire, et chaque paramètre de la fonction est initialisée avec son argument correspondant après conversion implicite si nécessaire. Si l'appel est effectué à une fonction membre, alors le pointeur this à l'objet courant est converti comme par conversion explicite au pointeur this attendue par la fonction. L'initialisation et la destruction de chaque paramètre se produit dans le contexte de l'appelant, ce qui signifie, par exemple, que si un paramètre de constructeur de lève une exception près, les gestionnaires d'exceptions définies au sein de la fonction, même en tant que bloc de fonction-essayer, ne sont pas considérés . Si la fonction est une fonction variadique, promotions arguments par défaut sont appliquées à tous les arguments correspondants au paramètre ellipse .
Original:
To call the function, all expressions A1, A2, A3, etc, provided as arguments are evaluated in arbitrary order, and each function parameter is initialized with its corresponding argument after conversion implicite if neccessary. If the call is made to a member function, then the this pointer to current object is converted as if by explicit cast to the this pointer expected by the function. The initialization and destruction of each parameter occurs in the context of the caller, which means, for example, that if constructor of a parameter throws an exception, the exception handlers defined within the function, even as a function-try block, are not considered. If the function is a variadic function, promotions arguments par défaut are applied to all arguments matched by the ellipsis parameter.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Le type de retour d'une expression d'appel de la fonction est le type de retour de la fonction choisie, a décidé aide de la liaison statique (sans tenir compte de la virtual) mot-clé), même si la fonction primordiale qui est en fait appelée retourne un type différent. Cela permet aux fonctions impérieuses de renvoyer des pointeurs ou des références à des classes dérivées du type de retour renvoyé par la fonction de base, c'est-à C + + supports Les types de retour covariants). Si E spécifie un destructeur, le type de retour est void .
Original:
The return type of a function call expression is the return type of the chosen function, decided using static binding (ignoring the virtual) keyword), even if the overriding function that's actually called returns a different type. This allows the overriding functions to return pointers or references to classes that are derived from the return type returned by the base function, i.e. C++ supports Les types de retour covariants). If E specifies a destructor, the return type is void.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
La catégorie la valeur d'une expression d'appel de fonction est lvalue si la fonction retourne une référence lvalue ou une référence rvalue de fonction, est un xValue si la fonction retourne une référence rvalue à l'objet, et est un prvalue autrement. Si l'expression est un appel de fonction prvalue du type d'objet, il doit être de type complet, sauf lorsqu'il est utilisé comme opérande à decltype .
Original:
The value category of a function call expression is lvalue if the function returns an lvalue reference or an rvalue reference to function, is an xvalue if the function returns an rvalue reference to object, and is a prvalue otherwise. If the function call expression is a prvalue of object type, it must have complete type except when used as an operand to decltype.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Expression appel de fonction est similaire à la syntaxe de la valeur d'initialisation T(), à l'expression fonction de style coulé T(A1), et pour diriger l'initialisation d'un T(A1, A2, A3, ...) temporaire, où T est le nom d'un type .
Original:
Function call expression is similar in syntax to value initialization T(), to fonction de style coulé expression T(A1), and to direct initialization of a temporary T(A1, A2, A3, ...), where T is the name of a type.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
#include <cstdio>
struct S
{
    int f1(double d) {
        printf("%f \n", d); // variable argument function call
    }
    int f2() {
        f1(7); // member function call, same as this->f1()
               // integer argument converted to double
    }
};
void f() {
   puts("function called"); // function call
}
int main()
{
    f(); // function call
    S s;
    s.f2(); // member function call
}

Résultat :

function called
7.000000

[modifier] Built-in opérateur virgule

Dans un E1, E2 la virgule, le E1 expression est évaluée, sa valeur de retour est ignorée et ses effets secondaires sont terminées avant l'évaluation de l'expression commence E2 (à noter que cette capacité est perdue avec défini par l'utilisateur operator,) .
Original:
In a comma expression E1, E2, the expression E1 is evaluated, its return value is discarded, and its side effects are completed before evaluation of the expression E2 begins (note that this ability is lost with user-defined operator,).
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Le type de retour et de la catégorie de valeur de l'opérateur virgule sont exactement le type de retour et la catégorie de valeur du deuxième opérande, E2 .
Original:
The return type and value category of the comma operator are exactly the return type and the value category of the second operand, E2.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
La virgule dans diverses listes séparées par des virgules, comme les listes d'arguments de fonction (f(a, b, c)), les listes initialiseur int a[] = {1,2,3}, ou des déclarations d'initialisation (int i, j;) n'est pas l'opérateur virgule. Si l'opérateur virgule doit être utilisée dans ce contexte, elle doit être mise entre parenthèses: f(a, (n++, n+b), c)
Original:
The comma in various comma-separated lists, such as function argument lists (f(a, b, c)), initializer lists int a[] = {1,2,3}, or initialization statements (int i, j;) is not the comma operator. If the comma operator needs to be used in that context, it has to be parenthesized: f(a, (n++, n+b), c)
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
#include <iostream>
int main()
{
    int n = 1;
    int m = (++n, std::cout << "n = " << n << '\n', ++n, 2*n);
    std::cout << "m = " << (++m, m) << '\n';
}

Résultat :

n = 2
m = 7

[modifier] Built-in opérateur de conversion

Le (T)expr intégré de conversion opérateur évalue l'expression et exécute expr conversion explicite à la T type .
Original:
The built-in conversion operator (T)expr evaluates the expression expr and performs explicit cast to the type T.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Voir conversion explicite pour une description détaillée .
Original:
See conversion explicite for detailed description.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

[modifier] L'opérateur conditionnel

Pour chaque paire de types arithmétique promu L et R et pour chaque type P, où P est un pointeur, le pointeur-à-membre, ou type d'énumération portée, les signatures de fonction suivants participent à la résolution de surcharge:
Original:
For every pair of promoted arithmetic types L and R and for every type P, where P is a pointer, pointer-to-member, or scoped enumeration type, 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.
LR operator?:(bool, L, R );
T operator?:(bool, T, T );
où LR est le résultat d'conversions arithmétiques usuelles effectuée sur L et R. L'opérateur ":" ne peut pas être surchargé, ces signatures de fonction n'existent que dans le but de la résolution de surcharge .
Original:
where LR is the result of conversions arithmétiques usuelles performed on L and R. The operator “?:” cannot be overloaded, these function signatures only exist for the purpose of overload resolution.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Le premier opérande de l'opérateur conditionnel est évalué et contexte convertis à bool. Après tant de l'évaluation de valeur et les effets secondaires des premier opérande sont terminés, si le résultat était true, le second opérande est évalué. Si le résultat est false, le troisième opérande est évalué .
Original:
The first operand of the conditional operator is evaluated and contexte convertis to bool. After both the value evaluation and all side effects of the first operand are completed, if the result was true, the second operand is evaluated. If the result was false, the third operand is evaluated.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Dans le E1 ? E2 : E3 expression conditionnelle, les règles et restrictions suivantes s'appliquent:
Original:
In the conditional expression E1 ? E2 : E3, the following rules and limitations apply:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
1)
Si l'une ou E2 E3 (ou les deux) est un throw-expression, le résultat de l'opérateur conditionnel est le résultat de l'autre (pas jeter) d'expression, et est un prvalue (après lvalue-à-rvalue, array-à-pointeur , ou de la fonction à pointeur de conversion). Un tel opérateur conditionnel est couramment utilisé dans programmation constexpr .
Original:
If either E2 or E3 (or both) is a throw-expression, the result of the conditional operator is the result of the other (not throw) expression, and is a prvalue (after lvalue-to-rvalue, array-to-pointer, or function-to-pointer conversion). Such conditional operator is commonly used in programmation constexpr.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
2)
Si les deux E2 ou E3 sont des void type, le résultat est un prvalue de type void .
Original:
If both E2 or E3 are of type void, the result is a prvalue of type void.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
3)
E2 et E3 ont différents types de classes (ou de même type avec différents cv-qualification) et la catégorie même valeur. Dans ce cas, une tentative est faite pour convertir une (et un seul) des opérandes du type de l'autre, comme suit:
Original:
E2 and E3 have different class types (or same type with different cv-qualification) and the same value category. In this case, an attempt is made to convert one (and only one) of the operands to the type of the other, as follows:
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
a)
Si elles sont lvalues, une conversion implicite du type de référence lvalue est tentée
Original:
If they are lvalues, an implicit conversion to the lvalue reference type is attempted
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
b)
Si elles sont XValues, une conversion implicite du type de référence rvalue est tentée
Original:
If they are xvalues, an implicit conversion to the rvalue reference type is attempted
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
c)
Si elles sont rvalues, et ont la même classe de base (ou l'un est une classe de base de l'autre), l'opérande (s) sont convertis au type de base par copier-initialisation d'un objet temporaire du type de base .
Original:
If they are rvalues, and have the same base class (or one is a base class of the other), the operand(s) are converted to the base type by copy-initializing a temporary object of the base type.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
d)
Si elles sont rvalues, et n'ont pas de classe de base commune, puis une conversion implicite est tenté de le type de l'autre opérande .
Original:
If they are rvalues, and have no common base class, then an implicit conversion is attempted to the type of the other operand.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
4)
Deux ou E2 E3 sont glvalues ​​du même type. Dans ce cas, le résultat est du même type et de la catégorie de valeur .
Original:
Both E2 or E3 are glvalues of the same type. In this case, the result has the same type and value category.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
5)
Si tous les cas énumérés ci-dessus échouent, et soit E2 ou E3 a le type de classe: la résolution de surcharge est tenté de sélectionner la meilleure conversion d'un type à l'autre .
Original:
If all cases listed above fail, and either E2 or E3 has class type: overload resolution is attempted to select the best conversion from one type to the other.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
6)
Si tous les cas énumérés ci-dessus échouent, et ni E2 ni E3 avez type de classe: tout d'abord, lvalue-à-rvalue, array-à-pointeur et la fonction à pointeur conversions sont appliquées. Puis,
Original:
If all cases listed above fail, and neither E2 nor E3 have class type: first, lvalue-to-rvalue, array-to-pointer, and function-to-pointer conversions are applied. Then,
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
a)
si les deux E2 et E3 maintenant avoir le même type, le résultat est un prvalue temporaire de ce type, la copie initialisée à partir de n'importe quel opérande a été sélectionné après une évaluation E1
Original:
if both E2 and E3 now have the same type, the result is a prvalue temporary of that type, copy-initialized from whatever operand was selected after evaluating E1
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
b)
E2 et E3 sont de type arithmétique ou une énumération: conversions arithmétiques habituelles sont appliquées pour les amener à type commun, ce type est le résultat .
Original:
E2 and E3 have arithmetic or enumeration type: usual arithmetic conversions are applied to bring them to common type, that type is the result.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
c)
E2 et E3 sont des pointeurs, ou un pointeur et d'une constante NULL ou un pointeur null constantes les deux, dont l'un est un std::nullptr_t, puis conversions de pointeurs et convrsions de qualification sont appliqués pour les amener à type commun, ce type est le résultat .
Original:
E2 and E3 are pointers, or a pointer and a null constant, or a both null pointer constants, one of which is a std::nullptr_t, then pointer conversions and qualification convrsions are applied to bring them to common type, that type is the result.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
d)
E2 et E3 sont des pointeurs vers les membres, ou un pointeur vers membre et une constante nulle: alors pointeur à membre les conversions et convrsions de qualification sont appliqués pour les amener à type commun, ce type est l'
Original:
E2 and E3 are pointers to members, or a pointer to member and a null constant: then pointer-to-member conversions and qualification convrsions are applied to bring them to common type, that type is the
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
#include <string>
#include <stdexcept>
struct Node
{
    Node* next;
    int data;
    // deep-copying copy constructor
    Node(const Node& other)
      : next(other.next ? new Node(*other.next) : NULL)
      , data(other.data)
    {}
    Node(int d) : next(NULL), data(d) {}
    ~Node() { delete next ; }
};
int main()
{   
    // simple rvalue example
    int n = 1>2 ? 10 : 11;  // 1>2 is false, so n = 11
    // simple lvalue example
    int m = 10; 
    (n == m ? n : m) = 7; // n == m is false, so m = 7
    // throw example
    std::string str = 2+2==4 ? "ok" : throw std::logic_error("2+2 != 4");
}


[modifier] Bibliothèque standard

De nombreuses classes de la bibliothèque standard remplacer operator() être utilisées comme des objets de fonction .
Original:
Many classes in the standard library override operator() to be used as function objects.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Modèle:cpp/utility/functional/function/dcl list operator()
supprime l'objet ou un tableau
Original:
deletes the object or array
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::default_delete)
compare ses arguments en utilisant propriétaire fondés sur la sémantique
Original:
compares its arguments using owner-based semantics
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(fonction)
retourne la somme de deux arguments
Original:
returns the sum of two arguments
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::plus) [edit]
renvoie la différence entre deux arguments
Original:
returns the difference between two arguments
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::minus) [edit]
retourne le produit de deux arguments
Original:
returns the product of two arguments
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::multiplies) [edit]
renvoie le résultat de la division du premier argument par le second argument
Original:
returns the result of the division of the first argument by the second argument
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::divides) [edit]
renvoie le reste de la division du premier argument par le second argument
Original:
returns the remainder from the division of the first argument by the second argument
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::modulus) [edit]
renvoie la négation de l'argument
Original:
returns the negation of the argument
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::negate) [edit]
vérifie si les arguments sont égaux
Original:
checks if the arguments are equal
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::equal_to) [edit]
vérifie si les arguments ne sont pas égaux
Original:
checks if the arguments are not equal
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::not_equal_to) [edit]
vérifie si le premier argument est supérieur au second
Original:
checks if the first argument is greater than the second
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::greater) [edit]
vérifie si le premier argument est inférieure à la seconde
Original:
checks if the first argument is less than the second
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::less) [edit]
vérifie si le premier argument est supérieur ou égal à la seconde
Original:
checks if the first argument is greater than or equal to the second
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::greater_equal) [edit]
vérifie si le premier argument est inférieur ou égal à la seconde
Original:
checks if the first argument is less than or equal to the second
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::less_equal) [edit]
retourne le ET logique des deux arguments
Original:
returns the logical AND of the two arguments
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::logical_and) [edit]
retourne le OU logique des deux arguments
Original:
returns the logical OR of the two arguments
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::logical_or) [edit]
retourne le NOT logique de l'argument
Original:
returns the logical NOT of the argument
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::logical_not) [edit]
renvoie le résultat de ET bit à bit de deux arguments
Original:
returns the result of bitwise AND of two arguments
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::bit_and) [edit]
renvoie le résultat d'un OU binaire de deux arguments
Original:
returns the result of bitwise OR of two arguments
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::bit_or) [edit]
renvoie le résultat de bit XOR de deux arguments
Original:
returns the result of bitwise XOR of two arguments
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::bit_xor) [edit]
renvoie le complément logique de la suite d'un appel à l'attribut stocké
Original:
returns the logical complement of the result of a call to the stored predicate
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::unary_negate) [edit]
renvoie le complément logique de la suite d'un appel à l'attribut stocké
Original:
returns the logical complement of the result of a call to the stored predicate
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::binary_negate) [edit]
appelle la fonction mémorisée
Original:
calls the stored function
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::reference_wrapper) [edit]
compare lexicographiquement deux chaînes en utilisant les facettes de ce lieu de rassembler
Original:
lexicographically compares two strings using this locale's collate facet
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 deux valeurs de value_type type
Original:
compares two values of type value_type
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::map::value_compare) [edit]
compare deux valeurs de value_type type
Original:
compares two values of type value_type
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::multimap::value_compare) [edit]
exécute la fonction
Original:
executes the function
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::packaged_task) [edit]
avancées état du moteur et retourne la valeur générée
Original:
advances the engine's state and returns the generated value
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::linear_congruential_engine) [edit]
génère le nombre aléatoire suivant dans la distribution
Original:
generates the next random number in the distribution
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::uniform_int_distribution) [edit]
Plusieurs classes de la bibliothèque standard fournissent des fonctions de conversion définis par l'utilisateur
Original:
Several standard library classes provide user-defined conversion functions
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.
Modèle:cpp/utility/functional/function/dcl list operator bool
vérifie si la valeur est non nulle
Original:
checks if the value is non-zero
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::error_code)
vérifie si la valeur est non nulle
Original:
checks if the value is non-zero
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::error_condition)
accède à l'élément de la bitset
Original:
accesses the element of the bitset
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::reference)
accède à l'élément de la <bool> vecteur
Original:
accesses the element of the vector<bool>
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::vector<bool>::reference)
vérifie si il est associé objet géré
Original:
checks if there is associated managed object
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::unique_ptr) [edit]
vérifie si il est associé objet géré
Original:
checks if there is associated managed object
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::shared_ptr) [edit]
accède à la référence mémorisée
Original:
accesses the stored reference
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::reference_wrapper)
convertit l'objet en value_type, retourne value
Original:
converts the object to value_type, returns value
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::integral_constant)
(avant C++11)
(depuis C++11)
vérifie si aucune erreur ne s'est produite (synonyme de !fail())
Original:
checks if no 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]
convertit le type chaîne sous-jacente
Original:
converts to the underlying string type
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::sub_match)
charge une valeur d'un objet atomique
Original:
loads a value from an atomic object
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::atomic) [edit]
teste si la serrure possède sa mutex associé
Original:
tests whether the lock owns its associated mutex
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::unique_lock) [edit]
convertit le pointeur managé à un pointeur de type différent
Original:
converts the managed pointer to a pointer to different type
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::auto_ptr)
L'opérateur virgule n'est pas surchargé par n'importe quelle classe dans la bibliothèque standard. La bibliothèque boost utilise operator, dans boost.assign, boost.spirit, et d'autres bibliothèques .
Original:
The comma operator is not overloaded by any class in the standard library. The boost library uses operator, in boost.assign, boost.spirit, and other libraries.
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

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