◐ Shell
clean mode source ↗

Arithmetic operators — cppreference.com

<metanoindex/>

Retourne le résultat de l'opération arithmétique spécifique .

Original:

Returns the result of specific arithmetic operation.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Operator name Syntax Over​load​able Prototype examples (for class T)
Inside class definition Outside class definition
unary plus +a Yes T T::operator+() const; T operator+(const T &a);
unary minus -a Yes T T::operator-() const; T operator-(const T &a);
addition a + b Yes T T::operator+(const T2 &b) const; T operator+(const T &a, const T2 &b);
subtraction a - b Yes T T::operator-(const T2 &b) const; T operator-(const T &a, const T2 &b);
multiplication a * b Yes T T::operator*(const T2 &b) const; T operator*(const T &a, const T2 &b);
division a / b Yes T T::operator/(const T2 &b) const; T operator/(const T &a, const T2 &b);
modulo a % b Yes T T::operator%(const T2 &b) const; T operator%(const T &a, const T2 &b);
bitwise NOT ~a Yes T T::operator~() const; T operator~(const T &a);
bitwise AND a & b Yes T T::operator&(const T2 &b) const; T operator&(const T &a, const T2 &b);
bitwise OR a | b Yes T T::operator|(const T2 &b) const; T operator|(const T &a, const T2 &b);
bitwise XOR a ^ b Yes T T::operator^(const T2 &b) const; T operator^(const T &a, const T2 &b);
bitwise left shift a << b Yes T T::operator<<(const T2 &b) const; T operator<<(const T &a, const T2 &b);
bitwise right shift a >> b Yes T T::operator>>(const T2 &b) const; T 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 intégré opérateurs valeurs de retour, et plus définies par l'utilisateur surcharges également renvoyer des valeurs de sorte que les opérateurs définis par l'utilisateur peuvent être utilisées 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). En d'insertion flux particulier, et les surcharges d'extraction de flux de operator<< et operator>> retour T& .

    Original:

    All built-in operators return values, and most user-defined overloads also return values 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). In particular, stream insertion and stream extraction overloads of operator<< and operator>> return T&.

    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.

Explication

Tous les opérateurs arithmétiques calculent le résultat de l'opération arithmétique spécifique et renvoie le résultat. Les arguments ne sont pas modifiés .

Original:

All arithmetic operators compute the result of specific arithmetic operation and returns its result. The arguments 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.

Conversions

Si l'opérande transmis à un opérateur arithmétique est entier ou type d'énumération sans portée, alors avant toute autre action (mais après lvalue rvalue à la conversion, le cas échéant), l'opérande subit promotion intégrale. Si un opérande est de type tableau ou fonction, un tableau à pointeur et la fonction à pointeur conversions sont appliquées .

Original:

If the operand passed to an arithmetic operator is integral or unscoped enumeration type, then before any other action (but after lvalue-to-rvalue conversion, if applicable), the operand undergoes promotion intégrale. If an operand has array or function type, array-to-pointer and function-to-pointer conversions are applied.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Pour les opérateurs binaires (à l'exception des changements), si les opérandes ont favorisé types différents, ensemble supplémentaire de conversion implicite est appliquée, appelée' conversions arithmétiques usuelles dans le but de produire du type' commun (également accessible par l'intermédiaire d' le trait de type std::common_type)

Original:

For the binary operators (except shifts), if the promoted operands have different types, additional set of implicit conversions is applied, known as usual arithmetic conversions with the goal to produce the common type (also accessible via the std::common_type type trait)

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

  • Si l'un des opérandes est de type énumération portée, aucune conversion n'est effectuée: l'autre opérande et le type de retour doit avoir le même type

    Original:

    If either operand has scoped enumeration type, no conversion is performed: the other operand and the return type must have the same type

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

  • Dans le cas contraire, si l'un des opérandes est long double, l'autre opérande est converti en long double

    Original:

    Otherwise, if either operand is long double, the other operand is converted to long double

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

  • Dans le cas contraire, si l'un des opérandes est double, l'autre opérande est converti en double

    Original:

    Otherwise, if either operand is double, the other operand is converted to double

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

  • Dans le cas contraire, si l'un des opérandes est float, l'autre opérande est converti en float

    Original:

    Otherwise, if either operand is float, the other operand is converted to float

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

  • Dans le cas contraire, l'opérande est de type entier (parce que bool, char, char16_t, char32_t, wchar_t, sans portée et le dénombrement ont été promus à ce stade) et conversions intégrales sont appliquées pour produire le type commun, comme suit:

    Original:

    Otherwise, the operand has integer type (because bool, char, char16_t, char32_t, wchar_t, and unscoped enumeration were promoted at this point) and conversions intégrales are applied to produce the common 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.

  • Si les deux opérandes sont signés ou les deux ne sont pas signés, l'opérande avec moins' rang de conversion est converti à l'opérande avec le grade de conversion supérieur entier

    Original:

    If both operands are signed or both are unsigned, the operand with lesser conversion rank is converted to the operand with the greater integer conversion rank

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

  • Dans le cas contraire, si le rang de conversion opérande non signé est supérieur ou égal au rang de conversion de l'opérande signé, l'opérande signé est converti en type de l'opérande non signé de .

    Original:

    Otherwise, if the unsigned operand's conversion rank is greater or equal to the conversion rank of the signed operand, the signed operand is converted to the unsigned operand's type.

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

  • Sinon, si le type signé opérande peut représenter toutes les valeurs de l'opérande non signé, l'opérande non signé est converti en type de l'opérande signataire

    Original:

    Otherwise, if the signed operand's type can represent all values of the unsigned operand, the unsigned operand is converted to the signer operand's type

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

  • Sinon, les deux opérandes sont convertis en contrepartie de type unsigned l'opérande signé le .

    Original:

    Otherwise, both operands are converted to the unsigned counterpart of the signed operand's type.

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

Le rang de conversion' ci-dessus augmente afin bool, signed char, short, int, long, long long. Le rang d'un type non signé est égal au rang du type correspondant signé. Le rang de char est égal au rang de signed char et unsigned char. Les rangs des char16_t, char32_t et wchar_t sont égaux dans les rangs de leurs types sous-jacents .

Original:

The conversion rank above increases in order bool, signed char, short, int, long, long long. The rank of any unsigned type is equal to the rank of the corresponding signed type. The rank of char is equal to the rank of signed char and unsigned char. The ranks of char16_t, char32_t, and wchar_t are equal to the ranks of their underlying types.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Débordements

Arithmétique de nombres entiers non signés est toujours effectué modulo 2n
 où n est le nombre de bits dans cet entier particulière. Par exemple pour unsigned int, ajoutant un UINT_MAX donne 0, et en soustrayant un de 0 donne UINT_MAX .

Original:

Unsigned integer arithmetic is always performed modulo 2n
 where n is the number of bits in that particular integer. E.g. for unsigned int, adding one to UINT_MAX gives 0, and subtracting one from 0 gives UINT_MAX.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Une fois signée entier déborde d'opérations arithmétiques (le résultat ne rentre pas dans le type de résultat), le comportement est indéfini: il peut s'enrouler autour selon les règles de la représentation (généralement en complément à 2), il peut piéger sur certaines plates-formes ou en raison de compilateur options (par ex -ftrapv de GCC et Clang), ou peut être complètement optimized out by the compiler .

Original:

When signed integer arithmetic operation overflows (the result does not fit in the result type), the behavior is undefined: it may wrap around according to the rules of the representation (typically 2's complement), it may trap on some platforms or due to compiler options (e.g. -ftrapv in GCC and Clang), or may be completely optimized out by the compiler.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Opérateurs arithmétiques unaires

Pour chaque type arithmétique A promu et pour chaque type de T, les signatures de fonction suivants participent à la résolution de surcharge:

Original:

For every promoted arithmetic type A and for every type T, 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.

<tbody> </tbody>

A operator+(A)

T* operator+(T*)

A operator-(A)

Le unaire, plus builtin opérateur retourne la valeur de son opérande. La seule situation où il n'est pas un no-op, c'est quand l'opérande est de type intégral ou de type énumération sans portée, qui est modifiée par la promotion intégrale, par exemple, il se convertit à char int ou si l'opérande est soumise à lvalue-à-rvalue, array-à-pointeur, ou de la fonction à pointeur conversion .

Original:

The builtin unary plus operator returns the value of its operand. The only situation where it is not a no-op is when the operand has integral type or unscoped enumeration type, which is changed by integral promotion, e.g, it converts char to int or if the operand is subject to lvalue-to-rvalue, array-to-pointer, or function-to-pointer conversion.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Le unaire moins builtin opérateur calcule le négatif de son opérande. Pour a non signé, la valeur de -a est 2b
-a, où b est le nombre de bits après la promotion .

Original:

The builtin unary minus operator calculates the negative of its operand. For unsigned a, the value of -a is 2b
-a, where b is the number of bits after promotion.

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()
{
    char c = 0x6a;
    int n1 = 1;
    unsigned char n2 = 1;
    unsigned int n3 = 1;
    std::cout << "char: " << c << " int: " << +c << '\n'
              << "-1, where 1 is signed: " << -n1 << '\n'
              << "-1, where 1 is unsigned char: " << -n2 << '\n'
              << "-1, where 1 is unsigned int: " << -n3 << '\n';
    char a[3];
    std::cout << "size of array: " << sizeof a << '\n'
              << "size of pointer: " << sizeof +a << '\n';
}

Résultat : 

char: j int: 106
-1, where 1 is signed: -1
-1, where 1 is unsigned char: -1
-1, where 1 is unsigned int: 4294967295
size of array: 3
size of pointer: 8

Opérateurs d'ajout

Pour chaque paire de types arithmétiques promus L et R et pour chaque type d'objet T, 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 object type T, 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.

<tbody> </tbody>

LR operator+(L, R)

LR operator-(L, R)

T* operator+(T*, std::ptrdiff_t)

T* operator+(std::ptrdiff_t, T*)

T* operator-(T*, std::ptrdiff_t)

std::ptrdiff_t operator-(T*, T*)

où LR est le résultat de conversions arithmétiques habituelles sur L et R

Original:

where LR is the result of usual arithmetic conversions on L and R

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Avec des opérandes de type arithmétique ou dénombrement, le résultat binaire en plus de la somme des opérandes (après converesions arithmétiques usuelles), et le résultat de l'opérateur binaire est moins le résultat de la soustraction du second opérande à partir de la première (après conversion arithmétiques usuelles ) .

Original:

With operands of arithmetic or enumeration type, the result of binary plus is the sum of the operands (after usual arithmetic converesions), and the result of the binary minus operator is the result of subtracting the second operand from the first (after usual arithmetic conversions).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Si l'un des opérandes est un pointeur, les règles suivantes s'appliquent:

Original:

If any of the operands is a pointer, the following rules apply:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

  • Un pointeur non-ensemble objet est traité comme un pointeur vers le premier élément d'un tableau de taille 1 .

    Original:

    A pointer to non-array object is treated as a pointer to the first element of an array with size 1.

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

  • Si les points P pointeur vers l'élément ith d'un tableau, alors les expressions P+n, n+P et P-n sont des pointeurs du même type qui pointent vers le i+nth, i+nth, et l'élément i-nth du même réseau, respectivement. Le résultat de l'addition pointeur peut aussi être un pointeur d'un past-the-end (c'est-à-pointeur P tels que les points P-1 expression sur le dernier élément du tableau). Toutes les autres situations (c'est-à-tente de générer un pointeur qui ne pointe pas moins un élément du même réseau ou d'un passé à la fin) invoquer un comportement indéfini .

    Original:

    If the pointer P points to the ith element of an array, then the expressions P+n, n+P, and P-n are pointers of the same type that point to the i+nth, i+nth, and i-nth element of the same array, respectively. The result of pointer addition may also be a one-past-the-end pointer (that is, pointer P such that the expression P-1 points to the last element of the array). Any other situations (that is, attempts to generate a pointer that isn't pointing at an element of the same array or one past the end) invoke undefined behavior.

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

  • Si les points P pointeur vers l'élément ith d'un tableau, et les points Q pointeur à l'élément jth de la même gamme, le P-Q expression a la valeur i-j, si la valeur s'inscrit dans std::ptrdiff_t. Les deux opérandes doivent pointer vers les éléments du tableau même (ou l'un après l'extrémité), sinon le comportement est indéfini. Si le résultat ne correspond pas à std::ptrdiff_t, le comportement est indéfini .

    Original:

    If the pointer P points to the ith element of an array, and the pointer Q points at the jth element of the same array, the expression P-Q has the value i-j, if the value fits in std::ptrdiff_t. Both operands must point to the elements of the same array (or one past the end), otherwise the behavior is undefined. If the result does not fit in std::ptrdiff_t, the behavior is undefined.

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

  • Si le 0 valeur est ajoutée ou soustraite d'un pointeur, le résultat est le pointeur, inchangé. Si deux pointeurs ponctuelles au même objet ou sont à la fois un passé à la fin du même réseau, ou les deux sont des pointeurs NULL, alors le résultat de la soustraction est égal à (std::ptrdiff_t)0 .

    Original:

    If the value 0 is added or subtracted from a pointer, the result is the pointer, unchanged. If two pointers point at the same object or are both one past the end of the same array, or both are null pointers, then the result of subtraction is equal to (std::ptrdiff_t)0.

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

Ces opérateurs arithmétiques de pointeur pointeurs permettent de satisfaire le concept RandomAccessIterator .

Original:

These pointer arithmetic operators allow pointers to satisfy the RandomAccessIterator concept.

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()
{
    char c = 2;
    unsigned int un = 2;
    int  n = -10;
    std::cout <<  " 2 + (-10), where 2 is a char    = " << c + n << '\n'
              <<  " 2 + (-10), where 2 is unsigned  = " << un + n << '\n'
              <<  " -10 - 2.12  = " << n - 2.12 << '\n';

    char a[4] = {'a', 'b', 'c', 'd'};
    char* p = &a[1];
    std::cout << "Pointer addition examples: " << *p << *(p + 2)
              << *(2 + p) << *(p - 1) << '\n';
    char* p2 = &a[4];
    std::cout << "Pointer difference: " << p2 - p << '\n';
}

Résultat : 

2 + (-10), where 2 is a char    = -8
 2 + (-10), where 2 is unsigned  = 4294967288
 -10 - 2.12  = -12.12
Pointer addition examples: bdda
Pointer difference: 3

Opérateurs de multiplication

Pour chaque paire de types arithmétiques promus LA et RA et pour chaque paire de types intégraux LI promus et RI la suite de signatures de fonction participer à la résolution de surcharge:

Original:

For every pair of promoted arithmetic types LA and RA and for every pair of promoted integral types LI and RI 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.

<tbody> </tbody>

LRA operator*(LA, RA)

LRA operator/(LA, RA)

LRI operator%(LI, RI)

où LRx est le résultat de conversions arithmétiques habituelles sur Lx et Rx

Original:

where LRx is the result of usual arithmetic conversions on Lx and Rx

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

L'opérateur binaire * effectue la multiplication de ses opérandes (après conversions arithmétiques habituelles) .

Original:

The binary operator * performs multiplication of its operands (after usual arithmetic conversions).

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

L'opérateur binaire / divise le premier opérande par le second (après conversions arithmétiques habituelles). Si le second opérande est égal à zéro, le comportement est indéfini. Pour les opérandes entiers, il donne le quotient algébrique

Original:

The binary operator / divides the first operand by the second (after usual arithmetic conversions).If the second operand is zero, the behavior is undefined. For integral operands, it yields the algebraic quotient

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

  • arrondis à la mise en oeuvre définie par (avant C++11) direction

    Original:

    rounded in implementation-defined direction (avant C++11)

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

  • la partie décimale éliminée (tronquée vers zéro) (depuis C++11)

    Original:

    with any fractional part discarded (truncated towards zero) (depuis C++11)

    The text has been machine-translated via Google Translate.
    You can help to correct and verify the translation. Click here for instructions.

L'opérateur binaire% donne le reste de la division du premier opérande par le second (après conversions arithmétiques habituelles). Si le quotient est a/b representible dans le type de résultat, (a/b)*b + a%b == a. Si le second opérande est égal à zéro, le comportement est indéfini .

Original:

The binary operator % yields the remainder of the division of the first operand by the second (after usual arithmetic conversions). If the quotient a/b is representible in the result type, (a/b)*b + a%b == a. If the second operand is zero, the behavior is undefined.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

  • si une ou les deux opérandes sont négatifs, le signe du reste est définie par la mise en oeuvre, car elle dépend de la direction de l'arrondi (avant C++11) division entière

    Original:

    if one or both operands are negative, the sign of the remainder is implementation-defined, as it depends on the rounding direction of integer division (avant C++11)

    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()
{
    char c = 2;
    unsigned int un = 2;
    int  n = -10;
    std::cout <<  "2 * (-10), where 2 is a char    = " << c * n << '\n'
              <<  "2 * (-10), where 2 is unsigned  = " << un * n << '\n'
              <<  "-10 / 2.12  = " << n / 2.12 << '\n'
              <<  "-10 / 21  = " << n / 21 << '\n'
              <<  "-10 % 21  = " << n % 21 << '\n';
}

Résultat : 

2 * (-10), where 2 is a char    = -20
2 * (-10), where 2 is unsigned  = 4294967276
-10 / 2.12  = -4.71698
-10 / 21  = 0
-10 % 21  = -10

Opérateurs logiques bit à bit

Pour chaque paire de types intégraux L promus et R la suite de signatures de fonction participer à la résolution de surcharge:

Original:

For every pair of promoted integral types L and R 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.

<tbody> </tbody>

R operator~(R)

LR operator&(L, R)

LR operator^(L, R)

LR operator|(L, R)

où LR est le résultat de conversions arithmétiques habituelles sur L et R

Original:

where LR is the result of usual arithmetic conversions on L and R

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Le résultat de l'opérateur ~ est l'opérateur bitwise NOT (complément) la valeur de l'argument (après la promotion). Le résultat de l'opérateur & est l'opérateur de bits AND valeur des opérandes (après conversions arithmétiques habituelles). Le résultat de l'opérateur

Original:

est un OU binaire valeur des opérandes (après conversions arithmétiques habituelles). Le résultat de l'opérateur ^ est la valeur XOR bit à bit de l'opérande (après conversion arithmétiques usuelles)

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()
{
    std::cout << std::hex << std::showbase;
    uint16_t mask = 0x00f0;
    uint32_t a = 0x12345678;
    std::cout << "Value: " << a << " mask: " << mask << '\n'
              << "Setting bits: " << (a

Résultat : 

Value: 0x12345678 mask: 0xf0
Setting bits: 0x123456f8
Clearing bits: 0x12345608
Selecting bits: 0x70

Opérateurs de décalage au niveau du bit

Pour chaque paire de types intégraux L promus et R, les signatures de fonction suivants participent à la résolution de surcharge:

Original:

For every pair of promoted integral types L and R, 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.

<tbody> </tbody>

L operator<<(L, R)

L operator>>(L, R)

Les opérandes de l'haut-opérateurs de décalage au niveau du bit des types soit intégré ou de type énumération sans portée. Promotions intégrales sont effectuées sur les deux opérandes avant l'évaluation. Le type de retour est le type de l'opérande gauche après les promotions integal .

Original:

The operands of the built-in bitwise shift operators have either integral types or unscoped enumeration type. Integral promotions are performed on both operands before evaluation. The return type is the type of the left operand after integal promotions.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Pour a non signé, la valeur de a << b est la valeur de a * 2b
, réduit modulo la valeur maximale du type de retour plus 1 (c'est-à-décalage gauche est effectuée et les bits qui se décalés hors du type de destination sont éliminés). Pour a signé, la valeur de a << b est a * 2b
 s'il est représentable par le type de retour, sans quoi le comportement n'est pas défini .

Original:

For unsigned a, the value of a << b is the value of a * 2b
, reduced modulo maximum value of the return type plus 1 (that is, bitwise left shift is performed and the bits that get shifted out of the destination type are discarded). For signed a, the value of a << b is a * 2b
 if it is representable by the return type, otherwise the behavior is undefined.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Pour a non signé et pour a signé avec des valeurs non négatives, la valeur de a >> b est la partie entière de a/2b
. Pour a négatif, la valeur de a >> b est définie par l'implémentation (dans la plupart des implémentations, ce décalage arithmétique effectue droit, de sorte que le résultat reste négatif)

Original:

For unsigned a and for signed a with nonnegative values, the value of a >> b is the integer part of a/2b
. For negative a, the value of a >> b is implementation-defined (in most implementations, this performs arithmetic right shift, so that the result remains negative)

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Dans tous les cas, si la valeur de l'opérande droit est négative, ou est supérieure ou égale au nombre de bits de l'opérande gauche promu, le comportement n'est pas défini .

Original:

In any case, if the value of the right operand is negative or is greater or equal to the number of bits in the promoted left operand, the behavior is undefined.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

#include <iostream>
enum {ONE=1, TWO=2};
int main()
{
    std::cout << std::hex << std::showbase;
    char c = 0x10;
    unsigned long long ull = 0x123;
    std::cout << "0x123 << 1 = " << (ull << 1) << '\n'
              << "0x123 << 63 = " << (ull << 63) << '\n' // overflow in unsigned
              << "0x10 << 10 = " << (c << 10) << '\n';   // char is promoted to int
    long long ll = -1000;
    std::cout << std::dec << "-1000 >> 1 = " << (ll >> ONE) << '\n';
}

Résultat : 

0x123 << 1 = 0x246
0x123 << 63 = 0x8000000000000000
0x10 << 10 = 0x4000
-1000 >> 1 = -500

Bibliothèque standard

Les opérateurs arithmétiques sont surchargées pour de nombreux types de bibliothèques standard .

Original:

Arithmetic operators are overloaded for many standard library types.

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

Opérateurs arithmétiques unaires

met en œuvre + unaire et unaire -

Original:

implements unary + and unary -

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::chrono::duration) [edit]

s'applique opérateurs unaires aux nombres complexes

Original:

applies unary operators to complex numbers

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]

applique un opérateur arithmétique unaire pour chaque élément de la valarray

Original:

applies a unary arithmetic operator to each element of the valarray

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


(fonction membre publique de std::valarray) [edit]

Opérateurs d'ajout

modifie le point de temps de la durée donnée

Original:

modifies the time point by the given duration

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]

concatène deux chaînes ou une chaîne et un char

Original:

concatenates two strings or a string and a char

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]

progrès de l'itérateur

Original:

advances the iterator

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::reverse_iterator)

décrémente l'itérateur

Original:

decrements the iterator

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::reverse_iterator)

progrès de l'itérateur

Original:

advances the iterator

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::move_iterator)

décrémente l'itérateur

Original:

decrements the iterator

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::move_iterator)

effectue l'arithmétique sur les nombres complexes deux valeurs complexes ou d'un complexe et un scalaire

Original:

performs complex number arithmetics on two complex values 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]

des opérateurs binaires s'applique à chaque élément de valarrays deux, ou un valarray et une valeur

Original:

applies binary operators to each element of two valarrays, or a valarray and a value

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


(fonction générique) [edit]

Opérateurs de multiplication

met en œuvre des opérations arithmétiques avec des durées comme arguments

Original:

implements arithmetic operations with durations as arguments

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]

effectue l'arithmétique sur les nombres complexes deux valeurs complexes ou d'un complexe et un scalaire

Original:

performs complex number arithmetics on two complex values 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]

des opérateurs binaires s'applique à chaque élément de valarrays deux, ou un valarray et une valeur

Original:

applies binary operators to each element of two valarrays, or a valarray and a value

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


(fonction générique) [edit]

Opérateurs logiques bit à bit

effectue binaire AND, OR, XOR et NOT

Original:

performs binary AND, OR, XOR and NOT

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]

effectue des opérations logiques binaires sur bitsets

Original:

performs binary logic operations on bitsets

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


(fonction) [edit]

applique un opérateur arithmétique unaire pour chaque élément de la valarray

Original:

applies a unary arithmetic operator to each element of the valarray

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


(fonction membre publique de std::valarray)

des opérateurs binaires s'applique à chaque élément de valarrays deux, ou un valarray et une valeur

Original:

applies binary operators to each element of two valarrays, or a valarray and a value

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


(fonction générique)

Opérateurs de décalage au niveau du bit

des opérateurs binaires s'applique à chaque élément de valarrays deux, ou un valarray et une valeur

Original:

applies binary operators to each element of two valarrays, or a valarray and a value

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


(fonction générique)

effectue décalage binaire à gauche et déplacement vers la droite

Original:

performs binary shift left and shift right

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)

Tout au long de la bibliothèque standard, les opérateurs de décalage au niveau du bit sont généralement surchargé par E / S courant (std::ios_base& ou l'une des classes dérivées de celle-ci) à la fois l'opérande gauche et le type de retour. Ces opérateurs sont connus sous le nom d'insertion flux' et' extraction flux: opérateurs

Original:

Throughout the standard library, bitwise shift operators are commonly overloaded with I/O stream (std::ios_base& or one of the classes derived from it) as both the left operand and return type. Such operators are known as stream insertion and stream extraction operators:

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

extraits des données formatées

Original:

extracts formatted data

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_istream) [edit]

extrait des tableaux de caractères et de caractères

Original:

extracts characters and character arrays

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]

inserts en forme des données

Original:

inserts formatted data

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_ostream) [edit]

insère des données de caractères

Original:

inserts character data

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


(fonction) [edit]

sérialise et désérialise un nombre complexe

Original:

serializes and deserializes a complex number

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]

effectue flux d'entrée et de sortie de bitsets

Original:

performs stream input and output of bitsets

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


(fonction) [edit]
effectue des opérations d'entrée/sortie de flux sur des chaines de caractères
(fonction générique) [edit]

effectue flux d'entrée et de sortie sur le moteur de nombres pseudo-aléatoires

Original:

performs stream input and output on pseudo-random number engine

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


(fonction) [edit]

effectue flux d'entrée et de sortie sur la distribution de nombre pseudo-aléatoire

Original:

performs stream input and output on pseudo-random number distribution

The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.


(fonction) [edit]

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)