Voir la source de cpp/language/operator other

Vous n’avez pas le droit de modifier cette page, pour la raison suivante :
L’action que vous essayez de réaliser n’est permise qu’aux utilisateurs d’un des groupes : Utilisateurs, Administrateurs.
Vous pouvez voir et copier le contenu de cette page.
{{tr_note}}
{{title|Other operators}}
{{cpp/language/navbar}}
{| class="wikitable" style="font-size:85%;"
|-
! rowspan="2" | Operator name
! rowspan="2" | Syntax
! rowspan="2" | Over&#8203;load&#8203;able
! colspan="2" | Prototype examples (for {{c|class T}})
|-
! Inside class definition
! Outside class definition
|-
| function call
| {{tt|a(a1, a2)}}
| {{yes}}
| {{c|R T::operator()(Arg1 &a1, Arg2 &a2, ... ...);}}
| {{n/a}}
|-
| comma
| {{tt|a, b}}
| {{yes}}
| {{c|T2& T::operator,(T2 &b);}}
| {{c|T2& operator,(const T &a, T2 &b);}}
|-
| conversion
| {{tt|(''type'') a
| {{yes}}
| {{c|operator type()}}
| {{n/a}}
|-
| ternary conditional
| {{tt|a ? b : c}}
| {{no}}
| {{n/a}}
| {{n/a}}
|}

===Explication===
{{tr|Appel de la fonction'''' opérateur fournit une sémantique de fonction pour n'importe quel objet .|''function call'' operator provides function semantics for any object.}}

{{tr|'''' 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é .|''conversion operator'' converts given type to another type. The name of the operator must be the same as the type intended to be returned.}}

{{tr|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 .|''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.}}

====Built-in opérateur d'appel de fonction====
{{tr|Une expression d'appel de fonction, comme {{c|E(A1, A2, A3)}}, consiste en une expression qui désigne la fonction, {{tt|E}}, suivie d'une liste éventuellement vide de {{tt|A1, A2, A3, ...}} expressions entre parenthèses .|A function call expression, such as {{c|E(A1, A2, A3)}}, consists of an expression that names the function, {{tt|E}}, followed by a possibly empty list of expressions {{tt|A1, A2, A3, ...}}, in parentheses.}}

{{tr|L'expression qui désigne la fonction peut être|The expression that names the function can be}}
@a@ {{tr|lvalue expression qui se réfère à une fonction|lvalue expression that refers to a function}}
@b@ {{tr|pointeur de fonction|pointer to function}}
@c@ {{tr|expression explicite [[cpp/language/operator_member_access|classe d'accès membre]] qui sélectionne une fonction membre|explicit [[cpp/language/operator_member_access|classe d'accès membre]] expression that selects a member function}}
@d@ {{tr|implicite expression accès membre de classe, par exemple nom de la fonction membre utilisé dans une autre fonction membre .|implicit class member access expression, e.g. member function name used within another member function.}}

{{tr|La fonction (ou membre) nom spécifié par {{tt|E}} peuvent être surchargés, [[cpp/language/overload_resolution|résolution de surcharge]] règles utilisées pour déterminer les surcharges doit être appelé .|The function (or member) name specified by {{tt|E}} can be overloaded, [[cpp/language/overload_resolution|résolution de surcharge]] rules used to decide which overload is to be called.}}

{{tr|Si {{tt|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 .|If {{tt|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.}}

{{tr|Pour appeler la fonction, toutes les expressions {{tt|A1}}, {{tt|A2}}, {{tt|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 [[cpp/language/implicit_cast|conversion implicite]] si nécessaire. Si l'appel est effectué à une fonction membre, alors le pointeur {{c|this}} à l'objet courant est converti comme par conversion explicite au pointeur {{c|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, [[cpp/utility/variadic#Default conversions|promotions arguments par défaut]] sont appliquées à tous les arguments correspondants au paramètre ellipse .|To call the function, all expressions {{tt|A1}}, {{tt|A2}}, {{tt|A3}}, etc, provided as arguments are evaluated in arbitrary order, and each function parameter is initialized with its corresponding argument after [[cpp/language/implicit_cast|conversion implicite]] if neccessary. If the call is made to a member function, then the {{c|this}} pointer to current object is converted as if by explicit cast to the {{c|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, [[cpp/utility/variadic#Default conversions|promotions arguments par défaut]] are applied to all arguments matched by the ellipsis parameter.}}

{{tr|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 {{tt|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 [[enwiki:Covariant return type|Les types de retour covariants]]). Si {{tt|E}} spécifie un destructeur, le type de retour est {{c|void}} .|The return type of a function call expression is the return type of the chosen function, decided using static binding (ignoring the {{tt|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 [[enwiki:Covariant return type|Les types de retour covariants]]). If {{tt|E}} specifies a destructor, the return type is {{c|void}}.}}

{{tr|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 .|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.}}

{{tr|Expression appel de fonction est similaire à la syntaxe de la valeur d'initialisation {{c|T()}}, à l'expression [[cpp/language/explicit_cast|fonction de style coulé]] {{c|T(A1)}}, et pour diriger l'initialisation d'un {{c|T(A1, A2, A3, ...)}} temporaire, où {{tt|T}} est le nom d'un type .|Function call expression is similar in syntax to value initialization {{c|T()}}, to [[cpp/language/explicit_cast|fonction de style coulé]] expression {{c|T(A1)}}, and to direct initialization of a temporary {{c|T(A1, A2, A3, ...)}}, where {{tt|T}} is the name of a type.}}

{{example
 |
 | code=
#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
}
 | output=
function called
7.000000 
}}

====Built-in opérateur virgule====
{{tr|Dans un {{c|E1, E2}} la virgule, le {{tt|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 {{tt|E2}} (à noter que cette capacité est perdue avec défini par l'utilisateur {{tt|operator,}}) . |In a comma expression {{c|E1, E2}}, the expression {{tt|E1}} is evaluated, its return value is discarded, and its side effects are completed before evaluation of the expression {{tt|E2}} begins (note that this ability is lost with user-defined {{tt|operator,}}). }}

{{tr|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, {{tt|E2}} .|The return type and value category of the comma operator are exactly the return type and the value category of the second operand, {{tt|E2}}.}}

{{tr|La virgule dans diverses listes séparées par des virgules, comme les listes d'arguments de fonction ({{c|f(a, b, c)}}), les listes initialiseur {{c|1=int a[] = {1,2,3}}}, ou des déclarations d'initialisation ({{c|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: {{c|f(a, (n++, n+b), c)}}|The comma in various comma-separated lists, such as function argument lists ({{c|f(a, b, c)}}), initializer lists {{c|1=int a[] = {1,2,3}}}, or initialization statements ({{c|int i, j;}}) is not the comma operator. If the comma operator needs to be used in that context, it has to be parenthesized: {{c|f(a, (n++, n+b), c)}}}}

{{example
 |
 | code=
#include <iostream>
int main()
{
    int n = 1;
    int m = (++n, std::cout << "n = " << n << '\n', ++n, 2*n);
    std::cout << "m = " << (++m, m) << '\n';
}
 | output=
n = 2
m = 7
}}

====Built-in opérateur de conversion====
{{tr|Le {{c|(T)expr}} intégré de conversion opérateur évalue l'expression et exécute {{tt|expr}} conversion explicite à la {{tt|T}} type . |The built-in conversion operator {{c|(T)expr}} evaluates the expression {{tt|expr}} and performs explicit cast to the type {{tt|T}}. }}

{{tr|Voir [[cpp/language/explicit_cast|conversion explicite]] pour une description détaillée .|See [[cpp/language/explicit_cast|conversion explicite]] for detailed description.}}

====L'opérateur conditionnel====
{{tr|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:|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:}}
{{dcl begin}}
{{dcl | LR operator?:(bool, L, R );}}
{{dcl | T operator?:(bool, T, T );}}
{{dcl end}}
{{tr|où LR est le résultat d'[[cpp/language/operator_arithmetic|conversions arithmétiques usuelles]] effectuée sur {{tt|L}} et {{tt|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 .|where LR is the result of [[cpp/language/operator_arithmetic|conversions arithmétiques usuelles]] performed on {{tt|L}} and {{tt|R}}. The operator “?:” cannot be overloaded, these function signatures only exist for the purpose of overload resolution.}}

{{tr|Le premier opérande de l'opérateur conditionnel est évalué et [[cpp/language/explicit_cast|contexte convertis]] à {{c|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 {{c|true}}, le second opérande est évalué. Si le résultat est {{c|false}}, le troisième opérande est évalué .|The first operand of the conditional operator is evaluated and [[cpp/language/explicit_cast|contexte convertis]] to {{c|bool}}. After both the value evaluation and all side effects of the first operand are completed, if the result was {{c|true}}, the second operand is evaluated. If the result was {{c|false}}, the third operand is evaluated.}}

{{tr|Dans le {{c|E1 ? E2 : E3}} expression conditionnelle, les règles et restrictions suivantes s'appliquent:|In the conditional expression {{c|E1 ? E2 : E3}}, the following rules and limitations apply:}}

@1@{{tr|Si l'une ou {{tt|E2}} {{tt|E3}} (ou les deux) est un {{c|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 [[cpp/language/constexpr|programmation constexpr]] .|If either {{tt|E2}} or {{tt|E3}} (or both) is a {{c|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 [[cpp/language/constexpr|programmation constexpr]].}}
@2@{{tr|Si les deux {{tt|E2}} ou {{tt|E3}} sont des {{c|void}} type, le résultat est un prvalue de type {{c|void}} .|If both {{tt|E2}} or {{tt|E3}} are of type {{c|void}}, the result is a prvalue of type {{c|void}}.}}
@3@{{tr|{{tt|E2}} et {{tt|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:|{{tt|E2}} and {{tt|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:}}
:@a@ {{tr|Si elles sont lvalues, une conversion implicite du type de référence lvalue est tentée|If they are lvalues, an implicit conversion to the lvalue reference type is attempted}}
:@b@ {{tr|Si elles sont XValues, une conversion implicite du type de référence rvalue est tentée|If they are xvalues, an implicit conversion to the rvalue reference type is attempted}}
:@c@ {{tr|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 .|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.}}
:@d@ {{tr|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 .|If they are rvalues, and have no common base class, then an implicit conversion is attempted to the type of the other operand.}}
@4@{{tr|Deux ou {{tt|E2}} {{tt|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 .|Both {{tt|E2}} or {{tt|E3}} are glvalues of the same type. In this case, the result has the same type and value category.}}
@5@{{tr|Si tous les cas énumérés ci-dessus échouent, et soit {{tt|E2}} ou {{tt|E3}} a le type de classe: la résolution de surcharge est tenté de sélectionner la meilleure conversion d'un type à l'autre .|If all cases listed above fail, and either {{tt|E2}} or {{tt|E3}} has class type: overload resolution is attempted to select the best conversion from one type to the other.}}
@6@{{tr|Si tous les cas énumérés ci-dessus échouent, et ni {{tt|E2}} ni {{tt|E3}} avez type de classe: tout d'abord, lvalue-à-rvalue, array-à-pointeur et la fonction à pointeur conversions sont appliquées. Puis, |If all cases listed above fail, and neither {{tt|E2}} nor {{tt|E3}} have class type: first, lvalue-to-rvalue, array-to-pointer, and function-to-pointer conversions are applied. Then, }}
:@a@ {{tr|si les deux {{tt|E2}} et {{tt|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 {{tt|E1}}|if both {{tt|E2}} and {{tt|E3}} now have the same type, the result is a prvalue temporary of that type, copy-initialized from whatever operand was selected after evaluating {{tt|E1}}}}
:@b@ {{tr|{{tt|E2}} et {{tt|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 .|{{tt|E2}} and {{tt|E3}} have arithmetic or enumeration type: usual arithmetic conversions are applied to bring them to common type, that type is the result.}}
:@c@ {{tr|{{tt|E2}} et {{tt|E3}} sont des pointeurs, ou un pointeur et d'une constante NULL ou un pointeur null constantes les deux, dont l'un est un {{lc|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 .|{{tt|E2}} and {{tt|E3}} are pointers, or a pointer and a null constant, or a both null pointer constants, one of which is a {{lc|std::nullptr_t}}, then pointer conversions and qualification convrsions are applied to bring them to common type, that type is the result.}}
:@d@ {{tr|{{tt|E2}} et {{tt|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' |{{tt|E2}} and {{tt|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 }}

{{example
 |
 | code=
#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");
}
 | output=
}}

===Bibliothèque standard===
{{tr|De nombreuses classes de la bibliothèque standard remplacer {{tt|operator()}} être utilisées comme des objets de fonction .|Many classes in the standard library override {{tt|operator()}} to be used as function objects.}}
{{dsc begin}}
{{dsc mem fun | cpp/memory/default_delete/operator() |{{tr| supprime l'objet ou un tableau | deletes the object or array }}}}
{{dsc fun | cpp/memory/owner_less/operator() |{{tr| compare ses arguments en utilisant propriétaire fondés sur la sémantique| compares its arguments using owner-based semantics}}}}

{{dsc inc | cpp/utility/functional/plus/dsc operator()}}
{{dsc inc | cpp/utility/functional/minus/dsc operator()}}
{{dsc inc | cpp/utility/functional/multiplies/dsc operator()}}
{{dsc inc | cpp/utility/functional/divides/dsc operator()}}
{{dsc inc | cpp/utility/functional/modulus/dsc operator()}}
{{dsc inc | cpp/utility/functional/negate/dsc operator()}}
{{dsc inc | cpp/utility/functional/equal_to/dsc operator()}}
{{dsc inc | cpp/utility/functional/not_equal_to/dsc operator()}}
{{dsc inc | cpp/utility/functional/greater/dsc operator()}}
{{dsc inc | cpp/utility/functional/less/dsc operator()}}
{{dsc inc | cpp/utility/functional/greater_equal/dsc operator()}}
{{dsc inc | cpp/utility/functional/less_equal/dsc operator()}}
{{dsc inc | cpp/utility/functional/logical_and/dsc operator()}}
{{dsc inc | cpp/utility/functional/logical_or/dsc operator()}}
{{dsc inc | cpp/utility/functional/logical_not/dsc operator()}}
{{dsc inc | cpp/utility/functional/bit_and/dsc operator()}}
{{dsc inc | cpp/utility/functional/bit_or/dsc operator()}}
{{dsc inc | cpp/utility/functional/bit_xor/dsc operator()}}
{{dsc inc | cpp/utility/functional/unary_negate/dsc operator()}}
{{dsc inc | cpp/utility/functional/binary_negate/dsc operator()}}

{{dsc inc | cpp/utility/functional/reference_wrapper/dsc operator()}}
{{cpp/utility/functional/function/dcl list operator()}}
{{dsc inc | cpp/locale/locale/dsc operator()}}
{{dsc inc | cpp/container/value_compare/dsc operator() | map }}
{{dsc inc | cpp/container/value_compare/dsc operator() | multimap }}
{{dsc inc | cpp/thread/packaged_task/dsc operator()}}
{{dsc inc | cpp/numeric/random/engine/dsc operator() |linear_congruential_engine}} <!-- and all other engines -->
{{dsc inc | cpp/numeric/random/distribution/dsc operator() | uniform_int_distribution}} <!-- and all other distributions -->
<!-- also the deprecated pointer_to_unary_function, pointer_to_binary_function, mem_fun_t, mem_fun_ref_t, mem_fun1_ref_t, const_mem_fun_t, const_mem_fun1_t, const_mem_fun_ref_t, const_mem_fun1_ref_t, binder1st, binder2nd -->
{{dsc end}}

{{tr|Plusieurs classes de la bibliothèque standard fournissent des fonctions de conversion définis par l'utilisateur|Several standard library classes provide user-defined conversion functions}}
{{dsc begin}}
{{dsc mem fun | cpp/error/error_code/operator bool |{{tr| vérifie si la valeur est non nulle | checks if the value is non-zero }}}}
{{dsc mem fun | cpp/error/error_condition/operator bool |{{tr| vérifie si la valeur est non nulle | checks if the value is non-zero }}}}
{{dsc mem fun | cpp/utility/bitset/reference/operator bool |{{tr| accède à l'élément de la bitset | accesses the element of the bitset }}}}
{{dsc mem fun | cpp/container/vector_bool/reference/operator bool |{{tr| accède à l'élément de la <bool> vecteur | accesses the element of the vector<bool> }}}}
{{dsc inc | cpp/memory/unique_ptr/dsc operator bool}}
{{dsc inc | cpp/memory/shared_ptr/dsc operator bool}}
{{dsc mem fun | cpp/utility/functional/reference_wrapper/get | title=operator T& |{{tr| accède à la référence mémorisée | accesses the stored reference }}}}
{{cpp/utility/functional/function/dcl list operator_bool}}
{{dsc mem fun | cpp/types/integral_constant/operator_value_type | title=operator value_type |{{tr| convertit l'objet en {{tt|value_type}}, retourne {{tt|value}} | converts the object to {{tt|value_type}}, returns {{tt|value}} }}}}
{{dsc inc | cpp/io/basic_ios/dsc operator bool}}
{{dsc mem fun | cpp/regex/sub_match/str | title=operator string_type |{{tr| convertit le type chaîne sous-jacente| converts to the underlying string type}}}}
{{dsc inc | cpp/atomic/atomic/dsc operator_T}}
{{dsc inc | cpp/thread/unique_lock/dsc operator bool}}
{{dsc mem fun | cpp/memory/auto_ptr/operator_conv | title=operator auto_ptr<Y> |{{tr| convertit le pointeur managé à un pointeur de type différent| converts the managed pointer to a pointer to different type}}}}
{{dsc end}}

{{tr|L'opérateur virgule n'est pas surchargé par n'importe quelle classe dans la bibliothèque standard. La bibliothèque boost utilise {{tt|operator,}} dans [http://www.boost.org/doc/libs/1_49_0/libs/assign/doc/index.html#intro boost.assign], boost.spirit, et d'autres bibliothèques .|The comma operator is not overloaded by any class in the standard library. The boost library uses {{tt|operator,}} in [http://www.boost.org/doc/libs/1_49_0/libs/assign/doc/index.html#intro boost.assign], boost.spirit, and other libraries.}}

===Voir aussi===
[[cpp/language/operator precedence |La priorité des opérateurs]]
{{cpp/language/operators}}

[[de:cpp/language/operator other]]
[[en:cpp/language/operator other]]
[[es:cpp/language/operator other]]
[[it:cpp/language/operator other]]
[[ja:cpp/language/operator other]]
[[pt:cpp/language/operator other]]
[[ru:cpp/language/operator other]]
[[zh:cpp/language/operator other]]
Modèles utilisés par cette page :
Revenir à la page cpp/language/operator other.
cppreference.com

Rechercher

Espaces de noms

Variantes

Affichages

Actions

Voir la source de cpp/language/operator other

Navigation

Outils
