Capítulo 4: Expresiones aritméticas

CAPÍTULO 4

Expresiones aritméticas

C posee una amplia variedad de operadores. Una expresión aritmética se compone de operadores y operandos. Los operadores actúan sobre los operandos para obtener un resultado. Los operadores aritméticos más comúnmente utilizados son +, -, *, / y %.

El signo más (+) se emplea para sumar dos valores, el signo menos (-) para restar un valor de otro, el asterisco (*) para multiplicar dos valores, la división (/) para dividir un valor por otro, y el signo % para obtener el resto de una división entera. Estos símbolos se conocen como operadores binarios , pues operan sobre dos valores o variables.

La lista siguiente son ejemplos de expresiones aritméticas:

resultado = x - y;
total = capital+ interes;
cuadrado = x * x;
celcius = (fahrenheit - 32) / 1.8

Hay que notar que el signo igual (=) en las expresiones anteriores se conoce como operador de asignación. Asigna el valor de la derecha de dicho signo igual a la variable de la izquierda.

En la última expresión, se utilizan paréntesis para realizar primero cierta operación. Esto sucede porque en C, los operadores siguen unas reglas de preferencia. *, / y % tienen preferencia sobre + y -. Para soslayar esta preferencia, se deben utilizar paréntesis. Las expresiones con operadores de la misma preferencia se suelen evaluar de izquierda a derecha. Otro punto a tener en cuenta es que en una expresión que entraña una división, hay que tener cuidado de evitar la división por cero, que da como resultado infinito o un valor anómalo. En el capítulo 5 sobre declaraciones de control, veremos cómo hacer una revisión previa a la división para prevenir estos resultados.

Programa 4.1

/* Uso de varios operadores aritméticos */

#include <stdio.h>

main()
{
int var1 = 10;
int var2 = 2;
int var3 = 35;
int var4 = 8;
int resultado;
resultado = var1 + var2;

printf("La suma de var1 y var2 es %d\n", resultado);
resultado = var3 * var3;
printf("El cuadrado de var3 es %d\n", resultado);
resultado = var2 +var3 * var4; /* preferencia */
printf("var2 + var3 * var4 =%d\n", resultado);
}

Operador unitario

Un operador unitario es el que opera sobre un valor u operando. El signo menos (-) desempeña un papel doble: se utiliza para la sustracción como operador binario y para la negación como operador unitario. Este operador tiene mayor preferencia que el resto de los operadores aritméticos.

resultado = -x * y;

En la expresión anterior, si x tiene un valor 20 e y tiene un valor 2, el resultado contendrá un valor negativo de 40 (-40)

En C, algunos operadores tienen un equivalente abreviado: los operadores de incremento (++) y decremento (--). Ambos pueden fijarse para actuar anterior o posteriormente. Cuando actúan como preincremento o predecremento, el valor se computa antes de evaluar la expresión. Si actúan como postincremento o postdecremento, el valor se computa después de evaluar la expresión.

Estudiemos el resultado del siguiente programa:

Programa 4.2

/* Uso de los operadores de preincremento y postincremento */

#include <stdio.h>

main()

{

int x = 10;

printf("El valor de x antes del preincremento ++ es %d\n", ++x);

printf("El valor de x tras el postincremento ++ es %d\n",x++);

}

Este programa escribirá los siguientes resultados:

El valor de x antes del preincremento ++ es 11
El valor de x tras el postincremento ++ es 11

Hay que notar que incluso después de postincrementar x, seguimos obteniendo 11 como resultado. Esto ocurre porque x se evalúa antes de que se aplique la operación de incremento.

Operador coma

La coma se puede usar para separar expresiones. Cada una de estas expresiones se evalúa, y devuelve el valor de la expresión más a la derecha.

Veamos el siguiente ejemplo:

Programa 4.3

/* Expresiones separadas por coma */

#include <stdio.h>

main()

{

int Total, Val, Contador;

Total = 100;

Val = 10;

Contador = 50;

Total =(Val++,Contador-2);

printf("%d\n", Total);

}

El programa anterior escribe un valor 48, pues la expresión Contador-2 es la última que se considera. Si no hubiera habido paréntesis, se hubiera asignado a Total el valor de Val antes del incremento, porque el operador de asignación tiene mayor preferencia que el operador coma. La preferencia de operadores se explica en la última sección de este capítulo.

Operador ternario

En C, el operador ternario es la expresión condicional. Acepta tres operandos, y los símbolos que se utilizan son la interrogación (?) y los dos puntos (:).

El formato del operador ternario es:

condición ? expresión1 : expresión2

Si la condición es cierta, se evalúa la expresión1. En caso contrario se evalúa expresión2. Ejemplo:

x = 10;
y = x >9 ? 100 : 200;

Devuelve el valor y = 100.

Este es otro ejemplo del uso del operador ternario:

valor_max = (cantidad > valor) ? cantidad : valor;

Operador módulo

El operador módulo se representa con el símbolo % (porcentaje). La operación que realiza el módulo es distinta a la división. La operación % devuelve como resultado el resto que queda cuando el primer operando se divide por el segundo operando.

Programa 4.4

/* Operador módulo */

#include <stdio.h>

main()

{

int x = 25, y=10, z;

z = x % y;

printf ("x %% y es %d\n", z);

}

Señalemos que en la sentencia printf, el signo de porcentaje (%) se utiliza dos veces, porque printf usa lo que sigue al signo % para determinar qué imprimir en el siguiente argumento. En el programa anterior, como encuentra otro signo de porcentaje, entiende que lo que usted desea es que escriba un símbolo % e inserta uno en la sentencia.

Operadores lógicos

En la tabla 4.1 se muestran los operadores lógicos de C.

Tabla 4.1

&& Conjunción (Y)

|| Disyunción (O)

! Negación (NO)

Los operadores lógicos evalúan de izquierda a derecha las expresiones para devolver verdadero o falso. Verdadero se representa por un valor distinto de cero y falso como cero. Los operadores lógicos son distintos de los operadores para manejo de bits (bitwise) Y (&) y O (|), que se estudiarán en el capítulo 11).

Examinemos la siguiente expresión:

resultado = q1 && q2; /* resultado es verdadero si tanto q1 como q2 son distintos a cero */
resultado = q1 || q2; /* resultado es verdadero si q1 o q2 es distinto a cero */
resultado = !q1; /* resultado es verdadero sólo si q1 es cero */

Preferencia de operadores

La preferencia de un operador da el orden en el que los operadores se aplican en las expresiones: primero se aplica el operador de mayor preferencia, seguido por el siguiente en preferencia, etc. La asociabilidad de un operador nos dice el orden en que se evalúan las expresiones con operadores de la misma preferencia. En el Apéndice hay una lista de operadores, su preferencia y su asociabilidad.

Conversiones de tipos de datos

El lenguaje C realiza implícitamente la conversión de tipos de datos cuando es preciso. Cuando se asigna un valor de coma flotante a una variable entera, se trunca la parte decimal. Cuando se asigna un valor de 156,43 a una variable entera, se almacena 156 y se desprecia la parte decimal. Si se asigna el entero 200 a una variable de coma flotante, el valor se convierte en 200,000000 al almacenarlo.

Otro punto a retener es que cuando dos operandos de una expresión son enteros, la operación se lleva a cabo utilizando las reglas de la aritmética de enteros. Por tanto, la parte decimal del resultado de una división se ignorará, incluso si el resultado se asigna a una variable de coma flotante. Esto se demuestra en el programa 4.5. Si uno de los operandos es una variable de coma flotante, se aplicarán las reglas de la aritmética decimal.

Programa 4.5

/* Conversiones implícitas de tipo de datos en C */

#include <stdio.h>

main()
{
float f1 = 156.43, resultado;
int i1, i2 = 200;

resultado = i2 / 100;
printf ("%d dividido por 100 es %f\n", i2,resultado);

resultado = i2 / 100.0;
printf("%d dividido por 100.0 es %f\n", i2,resultado);
}

Cuestionario

Preguntas de revisión

Tareas

[Su opinión es importante. Si tiene un comentario, corrección o pregunta
respecto a este capítulo, envíe un mensaje a comments@peoi.org].

Anterior: Variables, tipos de datos
Siguiente: Control de flujo