Operadores Aritméticos

El lenguaje C++ cuenta con los operadores aritméticos básicos, más los operadores paréntesis () para dar
cierta prioridad a operaciones que lo requieran.

( + , - , * , / ) = (adición, sustracción, multiplicación, división)

y el símbolo % = operador módulo o resto de la división.

(En algoritmos puede aparecer como MOD() o como RESTO() )

Para ejemplarizar consideremos la definición de las variables a, b, result:

int result, a = 8, b = 2;

result = a % b; /* result = 0 */

result = a - b; /* result = 6 */

Ahora sea: b = 3;

result = a % b; /* 8 % 3 --> result = 2 */

result = a / 5; /* 8 / 5 --> result = 1 */

* Observe que la sentencia de asignación, termina con un punto y coma, y las variables se declaran sólo
una vez (caso de la variable b).

Diferencias de la división según el tipo de los operandos

a) Si uno o más de los operandos es una variable de tipo punto flotante (double, float), entonces la
división es real.

b) Si los dos operandos son variables enteras (int, long,short,byte), entonces la división es entera.

Tipo de División Resultado Ejemplo

int / int int 3/2=1

int / double double 3.0 / 2.0 = 1.5

double / int double 1.0 / 2 = 0.5

double / double double 6.0 / 5.0 = 1.2

Ejercicio: ¿Cuál es el valor final de a y de b una vez efectuadas las operaciones?

int a = 3;
double b = 2.0;

a = 3 / b; /* ¿a resulta 1 ó 1.5? */
b = 3 / 2; /* ¿Resultado en b? */
Operador de post y pre incremento

Generalmente en un programa, se tienen que hacer incrementos o decrementos de una unidad para
variables enteras de la manera: var = var + 1; o var = var - 1;

En C++ como también en otros lenguajes de programación, se ha incluido el operador ++ y -- para

realizar estas asignaciones de manera más corta.

variable++ , ++variable : variable = variable + 1

variable-- , --variable : variable = variable - 1

La mayor diferencia de estos métodos, se encuentra en la asignación de variables. En primer lugar,

veremos este tipo de asignación cuando en la sentencia no existe otra variable involucrada.

Ej:
int a = 5; /* la variable a, toma como valor 5*/
a++; /* la variable se post incrementa y toma el valor 6 */
++a; /* la variable se pre incrementa y toma el valor 7*/

El post y pre incremento en estas condiciones, producen el mismo efecto.

También es válido para var-- y --var y sólo es válido para variables de tipo entero.

Ahora bien, cuando este tipo de incrementos no son independientes, o sea hay otra(s) variable(s)
involucrada(s) se deben seguir ciertas reglas, que se ejemplifican a continuación:

post-incremento

int a = 7, b; /* a = 7 y b = 0 */
b = a++; /* primero b = 7 y luego a = a + 1 --> 8 */

La variable b toma el valor de a (o sea b = 7). Luego de la asignación, la variable a se incrementa,

tomando un valor final de 8.

pre-incremento

a = 8;
b = ++a;

En este caso, lo primero que se hace es incrementar la variable a (a = 8), para luego asignar ese valor a la
variable b (o sea b = 9).

* Todo lo anterior es válido para variables enteras y para el operador de decremento

Ejercicios

Hacer la traza de los siguientes segmentos de código

a)
int a = 3, b = 4, c;
a++;
b = ++a;
c = b / 2;
c--;
b = c++;
--b;
 valores finales: a = 5, b = 0, c = 2.

b)
int x, y = 3, z = 6;
--z;
x = z + y++;
x++;
z = --y + z;

valores finales : x = 9, y = 3, z = 8

Operadores de asignación aritmética

Continuando con la idea de contraer ciertas operaciones aritméticas, se usan abreviaciones para la
asignación de una variable, cuando está involucrada como operador.

Expresión Equivalente

a + = b; a = a + b;

a - = b; a = a - b;

a * = b; a = a * b;

a / = b; a = a / b;

a % = b; a = a % b;

Ejemplo:
int a = 2, b = 3; /* Se declaran dos variables enteras a = 2, b = 3 */

a += b; /* a = a + b = 2 + 3 = 5 */
Para mayor orden en el seguimiento de los valores, se escribe la expresión equivalente y a continuación se
evalúan los valores.

b *= 5; /* b = b * 5 = 3 * 5 = 15 */

a = ++b; /* b = b + 1 = 15 + 1 = 16; a = b = 16 */

Como existe una variable que se está pre-incrementando, lo primero que se hace es modificar el valor de
esa variable. Después de haber hecho esto, se evalúan los valores.

b += --a + 5; /* a = a - 1 = 16 - 1 = 15 ; b = b + a + 5 = 16 + 15 + 5 = 36 */

Después de incrementar la variable a, se escribe y evalúa la expresión equivalente.

a += b--; /* a = a + b = 15 + 36 = 51; b = b - 1 = 36 - 1 = 35 */

Como ahora b, se está post-incrementando, lo primero que se hace es evaluar la expresión equivalente, y
después finalmente incrementar la variable b. Valores finales: a = 51, b = 35.
Ejercicios

Determinar los valores finales para los siguientes segmentos de código

a)
int a = 2, b = 3, c = 5;
a++;
b += a;
c *= b;
b -= 3;
a %= 2;
c /= 5;
Los valores finales: a = 1, b = 3, c = 6

b)
int a = 1;
int b = 2;
b++;
b = ++a;
a *= 2;
b += a;
a = ++b + 2;
Los valores finales son: a = 9, b = 7

Operadores Relacionales
Los siguientes operadores son fundamentales para implementar las condiciones de las sentencias de
control.

El resultado de una comparación es un valor true o false.

Operador Descripción Ejemplo

< menor a<b

<= menor o igual a++ <= 122

> mayor x > 5 * b++

>= mayor o igual p >= 0.01

== igual A % 2 == 0

!= distinto t != true

Ejemplo:

5>1 /* true */
1 >= 5 /* false */
2 == 2 /* true */
2 != 2 /* false */
Ejercicio: determinar si las siguientes relaciones son true o false.

a) 7 <= 5
b) 2 > 6
c) 3 != 5
d) a == a + 1
e) b++ != b++

Operadores Lógicos
C++ proporciona operadores lógicos que se usan para simular los conceptos Y, O y NO del álgebra de
Boole.

Éstos se conocen con el nombre de conjunción, disyunción y negación respectivamente, y los operadores
correspondientes son &&, || y !. La precedencia de la conjunción y la disyunción es lo suficientemente
baja como para que no sea necesario utilizar paréntesis.

El operador && tiene mayor precedencia que el operador ||, mientras que ! se agrupa con los demás
operadores. Los argumentos y resultados de estos operadores lógicos son valores de tipo boolean.

Operador Descripción Ejemplo

&& AND (y) f > 0.0 && f <= 1.0

|| OR (o) e == 1 | | d == 2

! NOT (no) !encendido

En la siguiente tabla se muestran los resultados de aplicar los operadores lógicos para todos los posibles
valores de entrada.

X Y X && Y X | | Y !X

false False false false true

false Trae false true true

true False false true false

true Trae true true false

Ejercicio: Determinar el resultado de las siguientes operaciones o sentencias.

a) true || false && true

b) (false || false) && (!true)
c) !true && !false
d) !(5 > 7 || 8 > 0 && 1 == 2)
resp: a = true, b : false , c : false, d : true