Operadores aritméticos
| ||||||
Operadores aritméticos. Se usan para realizar cálculos de Aritmética de números reales y de aritmética de punteros. Pertenecen a dos grupos: unos aceptan operandos de tipo numérico; otros aceptan operandos de tipo puntero-a-tipoX. Además son de dos tipos; unarios (que aceptan un solo operando) y binarios (que aceptan dos).
Sumario
Operadores aritméticos
+ 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.
Clasificación
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 son los siguientes:
+= Asigna suma -= Asigna diferencia (resta) *= Asigna producto /= Asigna división %= Asigna resto (módulo)
Existen distintos operadores enmascarados bajo los mismos símbolos + y -. Es un caso de sobrecarga incluida en el propio lenguaje. Como en el resto de los casos de sobrecarga, el compilador deduce por el contexto de que versión del operador se trata.
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
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. En este caso ambos operandos 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 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. Ejemplo:
int z = *(ptr + 3); // x == 4
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; // x == 4
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 arr[5] = {1, 2, 3, 4, 5};
int* ptr = &arr[4]; // señala a 5
int x = *(ptr - 2); // x == 3
Operadores ± Unitarios
Cuando los operadores + y - se utilizan como operadores unitarios, las posibilidades sintácticas son:
+ <expresión-cast> - <expresión-cast>
En ambos casos <expresión-cast> debe ser de tipo numérico. Los resultados son respectivamente:
- Valor del operando expresión-cast después de cualquier promoción interna que sea necesaria.
- Valor negativo del operando expresión-cast después de cualquier promoción interna que se necesite.
Ejemplo:
int x = 7, y = 3; int r1 = - (y - x); // r1 == 4 int r2 = + (y - x); // r2 == -4 int r3 = - (x - y); // r3 == -4 int r4 = + (x - y); // r4 == 4
Operadores multiplicación y división
Los operadores binarios * (multiplicación) y / (división) realizan sus operaciones aritméticas correspondientes con todos los tipos numéricos (enteros y fraccionarios). Sintaxis
expresión-de-multiplicación * expresión-cast expresión-de-multiplicación / expresión-cast
Operador módulo
El operador binario % (operador de módulo) devuelve el resto de la división de dos enteros, no puede ser utilizado con números fraccionarios float o double. Sintaxis
expresión-de-multiplicación % expresión-cast
Ejemplo:
int resto = (6 % 4); cout << "El resto de 6/4 es " << resto << endl;
Salida:
El resto de 6/4 es 2
Operadores incremento y decremento
Los operadores unitarios ++ (incremento) y -- (decremento), suman y restan respectivamente una unidad al valor de la expresión. Existen dos variedades "Pre" y "Post" para cada uno de ellos. Las posibilidades sintácticas son:
postfix-expression ++ (postincremento) ++ expresión-unitaria (preincremento) postfix-expression -- (postdecremento) -- expresión-unitaria (predecremento)
En los ejemplos que siguen suponemos que originariamente n == 5. El postincremento añade uno a la expresión después de que se ha evaluado:
x = n++ ; // -> x == 5 y n == 6
El preincremento añade uno antes de que sea evaluada la expresión.
x = ++n ; // -> x == 6 y n == 6
El postdecremento resta uno del valor de la expresión después de que sea evaluada.
x = n-- ; // -> x == 5 y n == 4
El predecremento resta uno antes de la evaluación de la expresión.
x = --n ; // -> x == 4 y n == 4
En ambos casos, el operando debe ser una variable, no una expresión. Por ejemplo: (x+y)++ es ilegal.
Véase también
- Operadores
- Operadores lógicos
- Operadores de manejo de bits
- Operador condicional
- Operador coma
- Operadores relacionales
- Operadores de asignación
- Operadores de modelado de tipos
- Operadores añadidos a expresión
- Operador de acceso a ámbito
- Operadores de puntero
- Operador new
- Operador new con matrices
- Operador delete
- Operador sizeof
- Operador typeid
- Operador de preproceso
