Operadores

Operadores aritméticos

§1 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 .

-- Decremento unitario (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 ( 4.2.2).

§2 Observaciones

Los operadores aritméticos pertenecen a dos grupos: unos aceptan operandos de tipo numérico; otros aceptan operandos 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 artiméticos binaros:

+ 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 ( 4.9.2) son los siguientes:

+= Asigna suma

-= Asigna diferencia (resta)

*= Asigna producto

/= Asigna división

%= Asigna resto (módulo)

Tenga en cuenta que existen distintos operadores 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)

++ Preincremento 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.

§3 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

§3.1 Operador Suma binaria

Las posibilidades para los operandos en la expresión A + B son los siguientes:

1. A y B son tipos aritméticos, enteros o fraccionarios ( 2.2.1). En este caso ambos operandos están sujetos a las posibles conversiones aritméticas estándar ( 2.2.5) 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 B es 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 ( 4.2.2). Ejemplo:

int z = *(ptr + 3); // x == 4

§3.2 Operador Resta binaria.

Las posibilidades para los operandos en la expresión A - B son los siguientes:

1. A y B son de tipo aritmético, entero o fraccionario; las posibilidades son las mismas que en el caso 1 de la suma binaria expuesta anteriormente. El resultado es la resta aritmética de ambos operandos. Ejemplo:

int x = 10, y = 20;

int z = x - y; // z == -10

2. A y B son punteros a objetos de tipos compatibles. Ejemplo:

int arr[5] = {1, 2, 3, 4, 5};

int* pt1 = &arr[0]; // Señala a 1

int* pt2 = &arr[4]; // Señala a 5

int x = pt2 - pt1;

...