Operadores Aritmeticos

Operadores Aritméticos
Operadores aritméticos
Sinopsis
Los operadores aritméticos se usan para realizar cálculos de aritmética de números reales y de aritmética de punteros. C++ dispone de los siguientes:
+ Dos posibilidades: Suma binaria; más unitario.
++ Incremento unitario (dos clases)
- Dos posibilidades: Resta binaria; menos unitario.
-- Decrementounitario (dos clases)
* Multiplicación (este símbolo tiene también otros usos)
/ División .
% Resto o módulo .
Nota: la aritmética de números reales es la clásica de la escuela primaria. La de punteros es una aritmética un tanto especial y rudimentaria.
Observaciones
Los operadores aritméticos pertenecen a dos grupos: unos aceptan operando de tipo numérico; otros aceptanoperados de tipo puntero-a-tipoX [3]. Además son de dos tipos; unarios (que aceptan un solo operando) y binarios (que aceptan dos). La clasificación es la siguiente:
Operadores aritméticos unarios:
+ Más unitario.
++ Incremento unitario (dos clases)
- menos unitario.
-- Decremento unitario (dos clases)
Operadores aritméticos binarios:
+ Suma binaria.
-Resta binaria.
* Multiplicación
/ División.
% Resto o módulo.
Estos últimos pueden combinarse con el de asignación = para dar origen a operadores compuestos son los siguientes:
+= Asigna suma
-= Asigna diferencia (resta)
*= Asigna producto
/= Asigna división
%= Asigna resto (módulo)

Tenga en cuenta que existen distintosoperadores enmascarados bajo los mismos símbolos + y -. Es un caso de sobrecarga incluida en el propio lenguaje [1]. Como en el resto de los casos de sobrecarga, el compilador deduce por el contexto de que versión del operador se trata. Como veremos inmediatamente, en C++ es perfectamente válida una expresión del tipo:
int x = *ptr+-*++ptr;
En el ejemplo siguiente se muestran los casos posibles:int ai[] = {2, 3};
int* ptr = ai;
int r1 = +ai[0]; // L.3: más unitario sobre tipo numérico
int r2 = -ai[1] // L.3: menos unitario sobre tipo numérico
int r3 = ai[0] + ai[1]; // L.4: 2 + 3 suma binaria (de enteros)
int r4 = ai[1] - ai[0] // L.5: 3 - 2 resta binaria (de enteros)
int r5 = ai[0] + -ai[1]; // L.6: 2 +(-3) suma binaria seguida de menos unitario
int r6 =*ptr + -*++ptr; // L.7: Suma binaria (de enteros) a + (-b)

En L.7 coexisten tres operadores aritméticos no homogéneos (de izquierda a derecha):
+ Suma binaria entre valores numéricos tipo int. Los valores *ptr y -*++ptr
- Negación unitaria de un valor numérico tipo int; el valor *(++ptr)
++ Pre incremento de un puntero-a-int . Equivale a suma binaria de puntero y entero: ++ptr ==ptr = ptr + 1
Nota: aunque válida, la sentencia de L.7 es un ejemplo de expresión peligrosa y desaconsejada. En 4.9.0a se ha presentado una explicación del sorpresivo resultado ( 0 ) que se obtiene para L.6.
Suma y resta binaria
En el primer caso: suma y resta binaria, caben dos posibilidades sintácticas:
a- expresión-suma + expresión-de-multiplicación
b- expresión-suma -expresión-de-multiplicación
.1 Operador Suma binaria
Las posibilidades para los operados en la expresión A + B son los siguientes:
1. A y B son tipos aritméticos, enteros o fraccionarios. En este caso ambos operados están sujetos a las posibles conversiones aritméticas estándar y el resultado es la suma aritmética de ambos. Ejemplo:
int x = 10, y = 20;
int z = x + y; // z == 30
2. A es un entero y Bes un puntero a objeto. Ejemplo:
int arr[5] = {1, 2, 3, 4, 5};
int* ptr = &arr[0]; // Señala a 1
int x = *(2 + ptr); // x == 3
3. A es un puntero a objeto y B es un entero. En estos dos últimos casos se aplican las reglas de aritmética de punteros. Ejemplo:
int z = *(ptr + 3); // x == 4
.2 Operador Resta binaria.
Las posibilidades para los operandos en la expresión A - B...