Operadores aritméticos de C ++

Devuelve el resultado de una operación aritmética específica.

Explicación

Todos los operadores aritméticos calculan el resultado de una operación aritmética específica y devuelven su resultado. Los argumentos no se modifican.

Conversiones

Si el operando pasado a un operador aritmético es del tipo de enumeración integral o sin ámbito, antes de cualquier otra acción (pero después de la conversión de lvalor a r, si corresponde), el operando se somete a una promoción integral. Si un operando tiene un tipo de matriz o función, se aplican las conversiones de matriz a puntero y función a puntero.

Para los operadores binarios (excepto turnos), si los operandos promocionados tienen diferentes tipos, se aplica un conjunto adicional de conversiones implícitas, conocido como conversiones aritméticas habituales con el objetivo de producir el tipo común (también accesible a través del std::common_type tipo de rasgo). Si, antes de cualquier promoción integral, un operando es de tipo enumeración y el otro operando es de tipo de punto flotante o de enumeración diferente, este comportamiento está en desuso. (desde C ++ 20).

• Si alguno de los operandos tiene un tipo de enumeración dentro del ámbito, no se realiza ninguna conversión: el otro operando y el tipo de retorno deben tener el mismo tipo
• De lo contrario, si alguno de los operandos es long double, el otro operando se convierte a long double
• De lo contrario, si alguno de los operandos es double, el otro operando se convierte a double
• De lo contrario, si alguno de los operandos es float, el otro operando se convierte a float
• De lo contrario, el operando tiene un tipo entero (porque en este punto se promovieron bool, char, char8_t, char16_t, char32_t, wchar_t y la enumeración sin ámbito) y se aplican conversiones integrales para producir el tipo común, de la siguiente manera:
• Si ambos operandos están firmados o ambos sin firmar, el operando con menor rango de conversión se convierte en el operando con mayor rango de conversión de enteros
• De lo contrario, si el rango de conversión del operando sin signo es mayor o igual al rango de conversión del operando con signo, el operando con signo se convierte al tipo de operando sin signo.
• De lo contrario, si el tipo de operando con signo puede representar todos los valores del operando sin signo, el operando sin signo se convierte al tipo de operando con signo.
• De lo contrario, ambos operandos se convierten en la contraparte sin signo del tipo de operando firmado.

los rango de conversión arriba aumenta en orden bool, signed char, short, int, long, long long. El rango de cualquier tipo sin firmar es igual al rango del tipo con signo correspondiente. El rango de char es igual al rango de signed char y unsigned char. Las filas de char8_t, char16_t, char32_t, y wchar_t son iguales a los rangos de sus tipos subyacentes.

Desbordes

La aritmética de enteros sin signo siempre se realiza módulo 2norte
donde n es el número de bits de ese entero en particular. Por ejemplo, para unsigned int, agregando uno a UINT_MAX da ​0​, y restando uno de ​0​ da UINT_MAX.

Cuando la operación aritmética de enteros con signo se desborda (el resultado no encaja en el tipo de resultado), el comportamiento es indefinido: puede ajustarse según las reglas de la representación (típicamente el complemento de 2), puede atrapar en algunas plataformas o debido al compilador opciones (p. ej. -ftrapv en GCC y Clang), o puede ser completamente optimizado por el compilador.

Entorno de punto flotante

Si #pragma STDC FENV_ACCESS es compatible y configurado para ON, todos los operadores aritméticos de punto flotante obedecen la dirección de redondeo de punto flotante actual y notifican errores aritméticos de punto flotante como se especifica en math_errhandling a menos que forme parte de un inicializador estático (en cuyo caso no se generan excepciones de punto flotante y el modo de redondeo es el más cercano).

Contracción de punto flotante

A no ser que #pragma STDC FP_CONTRACT es compatible y configurado para OFF, toda la aritmética de punto flotante puede realizarse como si los resultados intermedios tuvieran un rango y precisión infinitos, es decir, se permiten optimizaciones que omiten errores de redondeo y excepciones de punto flotante. Por ejemplo, C ++ permite la implementación de (x*y) + z con una sola instrucción de CPU fusionada de adición múltiple u optimización de a = x*x*x*x; como tmp = x *x; a = tmp*tmp.

Sin relación con la contratación, los resultados intermedios de la aritmética de punto flotante pueden tener un rango y una precisión diferentes a los indicados por su tipo, ver FLT_EVAL_METHOD.

Formalmente, el estándar C ++ no garantiza la precisión de las operaciones de punto flotante.

Operadores aritméticos unarios

Las expresiones del operador aritmético unario tienen la forma.

1) unario plus (promoción). Para el operador integrado, expresión debe tener aritmética, enumeración sin ámbito o tipo de puntero. La promoción integral se realiza en el operando si tiene un tipo de enumeración integral o sin ámbito y determina el tipo de resultado.
2) unario menos (negación). Para el operador integrado, expresión debe tener un tipo de enumeración aritmética o sin ámbito. La promoción integral se realiza en el operando y determina el tipo de resultado.

El operador unario plus incorporado devuelve el valor de su operando. La única situación en la que no es una operación no operativa es cuando el operando tiene un tipo de enumeración integral o sin ámbito, que se cambia por promoción integral, por ejemplo, convierte char para int o si el operando está sujeto a conversión de lvalue a rvalue, matriz a puntero o función a puntero.

El operador menos unario incorporado calcula el negativo de su operando promocionado. Por no firmado a, El valor de -a es 2B
-a, donde b es el número de bits después de la promoción.

En resolución de sobrecarga contra operadores definidos por el usuario, para cada tipo aritmético promovido A y para todo tipo T, las siguientes firmas de funciones participan en la resolución de sobrecarga:

A operator+(A)

T* operator+(T*)

A operator-(A)

#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';
}

Producción:

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

Operadores aditivos

Las expresiones del operador aritmético aditivo binario tienen la forma.

1) Además Para el operador integrado, lhs y rhs debe ser uno de los siguientes:

• ambos tienen un tipo de enumeración aritmética o sin ámbito. En este caso, las conversiones aritméticas habituales se realizan en ambos operandos y determinan el tipo de resultado.
• uno es un puntero para completar el tipo de objeto, el otro tiene el tipo de enumeración integral o sin ámbito. En este caso, el tipo de resultado tiene el tipo de puntero.

2) resta Para el operador integrado, lhs y rhs debe ser uno de los siguientes:

• ambos tienen un tipo de enumeración aritmética o sin ámbito. En este caso, las conversiones aritméticas habituales se realizan en ambos operandos y determinan el tipo de resultado.
• lhs es un puntero para completar el tipo de objeto, rhs tiene un tipo de enumeración integral o sin ámbito. En este caso, el tipo de resultado tiene el tipo de puntero.
• ambos son punteros a los mismos tipos de objetos completos, ignorando los calificadores cv. En este caso, el tipo de resultado es std::ptrdiff_t.

Con operandos de tipo aritmético o enumeración, el resultado de binario más es la suma de los operandos (después de las conversiones aritméticas habituales), y el resultado del operador binario menos es el resultado de restar el segundo operando del primero (después de las conversiones aritméticas habituales). ), excepto que, si el tipo admite aritmética de punto flotante IEEE (consulte std::numeric_limits::is_iec559),

• si un operando es NaN, el resultado es NaN
• infinito menos infinito es NaN y FE_INVALID es elevado
• infinito más el infinito negativo es NaN y FE_INVALID es elevado

Si alguno de los operandos es un puntero, se aplican las siguientes reglas:

• Un puntero a un objeto que no es una matriz se trata como un puntero al primer elemento de una matriz con tamaño 1.
• Si el puntero P apunta al ith elemento de una matriz, luego las expresiones P+n, n+P, y P-n son punteros del mismo tipo que apuntan al i+nth, i+nth, y i-nth elemento de la misma matriz, respectivamente. El resultado de la suma de punteros también puede ser un puntero de una pasada al final (es decir, puntero P tal que la expresión P-1 apunta al último elemento de la matriz). Cualquier otra situación (es decir, los intentos de generar un puntero que no apunta a un elemento de la misma matriz o uno más allá del final) invocan un comportamiento indefinido.
• Si el puntero P apunta al ith elemento de una matriz, y el puntero Q apunta a la jth elemento de la misma matriz, la expresión P-Q tiene el valor i-j, si el valor encaja std::ptrdiff_t. Ambos operandos deben apuntar a los elementos de la misma matriz (o uno más allá del final), de lo contrario, el comportamiento no está definido. Si el resultado no encaja std::ptrdiff_t, el comportamiento no está definido.
• En cualquier caso, si el tipo apuntado a es diferente del tipo de elemento de matriz, sin tener en cuenta las calificaciones de cv, en todos los niveles si los elementos son en sí mismos apuntadores, el comportamiento de la aritmética de apuntadores no está definido. En particular, la aritmética de puntero con puntero a la base, que apunta a un elemento de una matriz de objetos derivados, no está definida.
• Si el valor ​0​ se suma o resta de un puntero, el resultado es el puntero, sin cambios. Si dos punteros apuntan al mismo objeto o ambos son uno más allá del final de la misma matriz, o ambos son punteros nulos, entonces el resultado de la resta es igual a (std::ptrdiff_t)0.

Estos operadores aritméticos de puntero Permitir que los punteros satisfagan los requisitos de LegacyRandomAccessIterator.

En resolución de sobrecarga contra operadores definidos por el usuario, para cada par de tipos aritméticos promocionados L y R y para cada tipo de objeto T, las siguientes firmas de funciones participan en la resolución de sobrecarga:

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

dónde LR es el resultado de las conversiones aritméticas habituales en L y R.

#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';
}

Producción:

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

Operadores multiplicativos

Las expresiones del operador aritmético multiplicativo binario tienen la forma.

1) multiplicación Para el operador integrado, lhs y rhs ambos deben tener un tipo de enumeración aritmética o sin ámbito.
2) división Para el operador integrado, lhs y rhs ambos deben tener un tipo de enumeración aritmética o sin ámbito.
3) resto Para el operador integrado, lhs y rhs ambos deben tener un tipo de enumeración integral o sin ámbito

Para los tres operadores, las conversiones aritméticas habituales se realizan en ambos operandos y determinan el tipo de resultado.

El operador binario * realiza la multiplicación de sus operandos (después de las conversiones aritméticas habituales), excepto que, para la multiplicación de coma flotante,

• la multiplicación de un NaN por cualquier número da NaN
• la multiplicación de infinito por cero da NaN y FE_INVALID es elevado

El operador binario / divide el primer operando por el segundo (después de las conversiones aritméticas habituales).

Para operandos integrales, produce el cociente algebraico.

Si el segundo operando es cero, el comportamiento no está definido, excepto que si se está realizando una división de punto flotante y el tipo admite aritmética de punto flotante IEEE (consulte std::numeric_limits::is_iec559), luego:

• si un operando es NaN, el resultado es NaN
• dividir un número distinto de cero por ± 0.0 da el infinito correctamente firmado y FE_DIVBYZERO es elevado
• dividir 0.0 por 0.0 da NaN y FE_INVALID es elevado

El operador binario% produce el resto de la división entera del primer operando por el segundo (después de las conversiones aritméticas habituales; tenga en cuenta que los tipos de operandos deben ser tipos integrales). Si el cociente a/b es representable en el tipo de resultado, (a/b)*b + a%b == a. Si el segundo operando es cero, el comportamiento no está definido. Si el cociente a/b no es representable en el tipo de resultado, el comportamiento de ambos a/b y a%b no está definido (eso significa INT_MIN%-1 no está definido en los sistemas de complemento a 2).

Nota: Hasta C ++ 11, si uno o ambos operandos del operador binario% eran negativos, el signo del resto estaba definido por la implementación, ya que depende de la dirección de redondeo de la división de enteros. La función std::div proporcionó un comportamiento bien definido en ese caso.

Nota: para el resto de coma flotante, consulte std::remainder y std::fmod.

En resolución de sobrecarga contra operadores definidos por el usuario, para cada par de tipos aritméticos promocionados LA y RA y para cada par de tipos integrales promovidos LI y RI las siguientes firmas de funciones participan en la resolución de sobrecarga:

LRA operator*(LA, RA)

LRA operator/(LA, RA)

LRI operator%(LI, RI)

dónde LRx es el resultado de las conversiones aritméticas habituales en Lx y Rx.

#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';
}

Producción:

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

Operadores lógicos bit a bit

Las expresiones del operador aritmético bit a bit tienen la forma.

1) bit a bit NO
2) bit a bit Y
3) O bit a bit
4) XOR bit a bit Para los operadores integrados, lhs y rhs ambos deben tener un tipo de enumeración integral o sin ámbito. Las conversiones aritméticas habituales se realizan en ambos operandos y determinan el tipo de resultado.

El resultado de operator ~ es el valor NOT bit a bit (complemento a uno) del argumento (después de la promoción). El resultado del operador & es el valor AND bit a bit de los operandos (después de las conversiones aritméticas habituales). El resultado del operador | es el valor OR bit a bit de los operandos (después de las conversiones aritméticas habituales). El resultado del operador ^ es el valor XOR bit a bit de los operandos (después de las conversiones aritméticas habituales).

En resolución de sobrecarga contra operadores definidos por el usuario, para cada par de tipos integrales promovidos L y R las siguientes firmas de funciones participan en la resolución de sobrecarga:

R operator~(R)

LR operator&(L, R)

LR operator^(L, R)

LR operator|(L, R)

dónde LR es el resultado de las conversiones aritméticas habituales en L y R.

#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 | mask) << 'n'
              << "Clearing bits: " << (a & ~mask) << 'n'
              << "Selecting bits: " << (a & mask) << 'n';
}

Producción:

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

Operadores de desplazamiento bit a bit

Las expresiones del operador de desplazamiento bit a bit tienen la forma.

1) desplazamiento a la izquierda de lhs por rhs bits
2) desplazamiento a la derecha de lhs por rhs bits Para los operadores integrados, lhs y rhs ambos deben tener un tipo de enumeración integral o sin ámbito. Las promociones integrales se realizan en ambos operandos.

El tipo de retorno es el tipo del operando izquierdo después de las promociones integrales.

En cualquier caso, si el valor del operando derecho es negativo o es mayor o igual al número de bits en el operando izquierdo promovido, el comportamiento es indefinido.

En resolución de sobrecarga contra operadores definidos por el usuario, para cada par de tipos integrales promovidos L y R, las siguientes firmas de funciones participan en la resolución de sobrecarga:

L operator<<(L, R)

L operator>>(L, R)

#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';
}

Producción:

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

Biblioteca estándar

Los operadores aritméticos están sobrecargados para muchos tipos de bibliotecas estándar.

Operadores aritméticos unarios

Operadores aditivos

Operadores multiplicativos

Operadores lógicos bit a bit

Operadores de desplazamiento bit a bit

Operadores de inserción / extracción de flujo

En toda la biblioteca estándar, los operadores de desplazamiento bit a bit suelen estar sobrecargados con flujo de E / S (std::ios_base& o una de las clases derivadas de él) como el operando izquierdo y el tipo de retorno. Estos operadores se conocen como inserción de flujo y extracción de corriente operadores:

Ver también

Precedencia del operador.

Sobrecarga del operador.