ASánchezDíaz

Autoaprendiendo .NET y otras cosas


Manual C# – Capítulo 1.3. Operadores I

En este capítulo vamos a hablar de los operadores. Los operadores son símbolos que determinan qué tipo de operación hay que realizar entre variables en una expresión.

Operadores aritméticos

Realizan operaciones aritméticas (suma, resta, multiplicación y división) entre dos parámetros:

Suma ( + )

La operación es interpretada de distinta forma dependiendo de si los sumandos son de tipo numérico o se trata de cadenas de texto. Por ejemplo, si tenemos dos variables de tipo int la operación dará como resultado la suma de las dos variables:

int sumando1 = 2;

int sumando2 = 3;

int resultado=sumando1+sumando2;

La variable resultado debe ser del tipo int, ya que ambos sumandos lo son, y su valor es 5.

Si se trata de dos variables de tipo string, el resultado es la concatenación de las dos cadenas de texto:

string cadena1 = "primera";
string cadena2 = "segunda";

string resultado = cadena1 + cadena2;

El resultado en este caso es “primerasegunda”.

Fíjate que en las dos operaciones anteriores (y en las demás) el resultado sería el mismo si en lugar de sumar las variables hubiésemos sumado su valor:

int resultado = 2 + 3;
string resultado = "primera" + "segunda";

Y esto es porque la variable almacena en memoria un valor, que es referenciado al usar la variable.

Resta ( – )

De idéntica forma a la suma, salvo que en este caso al valor de la primera variable se resta el de la segunda. En el ejemplo anterior el resultado sería -1.

El operador – no se puede usar en variables en las que la resta no tenga sentido. ¿Cómo se restan dos cadenas de texto? Obviamente hay un modo, pero ya lo veremos.

Multiplicación ( * )

Se representa mediante el símbolo asterisco (*). Realiza la multiplicación entre dos variables o valores.

División ( / )

Se representa mediante el signo ( / ) y realiza la división en los mismos términos que la multiplicación, aunque con matices. Si dividimos dos variables de tipo int, por ejemplo:

int numerador = 3;
int denominador = 2;

El resultado es 1.5, que no es del tipo int. Si intentamos hacer la operación:

int resultado = numerador / denominador;

No nos dará error, pero el valor de resultado no es 1.5 sino 1, es decir, C# ha “truncado” el valor y se ha quedado con su parte entera, si queremos obtener también los decimales, debemos guardar el resultado en una variable de tipo float o double.

Módulo ( % )

Da como resultado el resto de la división entre dos variables:

int valor = 5;
int valor = 2;

int resto = 5%2; obtenemos 1, ya que el resto entre 5 y 2 es 1.


Operadores relacionales

Comparan los dos términos que forman la operación. Se usan en casos en los que nos interesa comparar dos variables, por ejemplo, en instrucciones condicionales o bucles (ya los veremos). Son los siguientes:

Igualdad ( == )

Determina si los términos situados a ambos lados del operador son iguales, devolviendo true o false si efectivamente son iguales o no respectivamente:

int valor1 = 5;
int valor2 = 4;
int valor3 = 4;

bool resultado = (valor1 == valor2);  //obtenemos false
bool resultado = (valor2 == valor3); //obtenemos true

Hay que tener cuidado y saber diferenciar los operadores de asignación ( = ) e igualdad ( == ), el primero asigna el valor a la variable mientras que el segundo compara ambos términos. No es lo mismo:

valor1 = valor2; a valor 1 le asigna el valor de valor2
que
valor1 == valor2; que compara ambas variables y devuelve false

Desigualdad ( != )
Determina si ambos términos son desiguales. En este caso las operaciones anteriores serían:

int valor1 = 5;
int valor2 = 4;
int valor3 = 4;

bool resultado = (valor1 != valor2);  obtenemos true
bool resultado = (valor2 != valor3); obtenemos false

Mayor que ( > ), menor que ( < ), mayor o igual que ( >= ), menor o igual que ( <= )

Estos operadores evalúan ambos términos determinando si el de la derecha es mayor, menor, mayor o igual o menor o igua que el de la izquierda.

Por ejemplo:

int valor1 = 5;
int valor2 = 4;
int valor3 = 4;


bool resultado = (valor1 > valor2);  //obtenemos true
bool resultado = (valor2 < valor3); //obtenemos false bool resultado = (valor2 >= valor3); //obtenemos true
bool resultado = (valor2 <= valor3); //obtenemos true

En la próxima entrega veremos los operadores lógicos, muy importantes también en las estructuras condicionales, los operadores de asignación y tocaremos muy por encima los operadores de manipulación de bits.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *