Other 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

Operator name	Syntax	Overloadable	Prototype examples (for class T)
Operator name	Syntax	Overloadable	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 .

L'expression qui désigne la fonction peut être

a)

lvalue expression qui se réfère à une fonction

b)

pointeur de fonction

c)

expression explicite classe d'accès membre qui sélectionne une fonction membre

d)

implicite expression accès membre de classe, par exemple nom de la fonction membre utilisé dans une autre fonction membre .

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é .

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 .

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 .

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 .

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 .

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 .

#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,) .

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 .

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)

#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 .

Voir conversion explicite pour une description détaillée .

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

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 .

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é .

Dans le E1 ? E2 : E3 expression conditionnelle, les règles et restrictions suivantes s'appliquent:

1)

Si l'une ou E2E3 (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 .

2)

Si les deux E2 ou E3 sont des void type, le résultat est un prvalue de type void .

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:

a)

Si elles sont lvalues, une conversion implicite du type de référence lvalue est tentée

b)

Si elles sont XValues, une conversion implicite du type de référence rvalue est tentée

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 .

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 .

4)

Deux ou E2E3 sont glvalues du même type. Dans ce cas, le résultat est du même type et de la catégorie de valeur .

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 .

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,

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

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 .

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 .

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'

#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 exampleint n =1>2?10:11;// 1>2 is false, so n = 11// simple lvalue exampleint m =10;(n == m ? n : m)=7;// n == m is false, so m = 7// throw examplestd::string str =2+2==4?"ok":throwstd::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 .

Modèle:cpp/utility/functional/function/dcl list operator()


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

operator()	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)

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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]

operator()	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

Modèle:cpp/utility/functional/function/dcl list operator bool


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

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_condition`)

operator bool	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`)

operator bool	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`)

operator bool	vérifie si un objet est actuellement géré (fonction membre publique de `std::unique_ptr`)[edit]

operator bool	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]

operator T&	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`)

operator value_type	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`)

operator void* operator bool (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]

operator string_type	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`)

operator T	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]

operator bool	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]

operator auto_ptr<Y>	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 .

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

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

Espaces de noms

Variantes

Affichages

Actions