Operadores en C#

Operadores

Los operadores son símbolos que permiten realizar operaciones con uno o más datos, para dar un resultado. El ejemplo clásico y obvio de operador es el símbolo de la suma (+), aunque hay otros muchos.

Vamos a hacer un repaso a los tipos de operadores que tenemos en C#:

Operadores Aritméticos: Son la suma (+), resta (-), producto (*), división (/) y módulo (%)
Operadores Lógicos: Son "and" (&& y &), "or" (|| y |), "not" (!) y "xor" (^)

La diferencia entre && y &, y entre || y | es que && y || hacen lo que se llama "evaluación perezosa": si evaluando sólo la primera parte de la operacion se puede deducir el resultado, la parte derecha no se evaluará. Es decir, si tenemos por ejemplo:

     false && (otra cosa)

El resultado de esta operación siempre será false, y (otra cosa) ni siquiera se evalúa. De igual forma, si tenemos

     true || (otra cosa)

el resultado será true, y la parte derecha nunca se evaluará.

Operadores relacionales: igualdad (==), desigualdad (!=), "mayor que" (>), "menor que" (<), "mayor o igual que" (>=) y "menor o igual que" (<=)

Operadores de Manipulación de Bits: Tenemos las siguientes operaciones: and (&), or (|), not (~), xor (^), desplazamiento a la izquierda (<<), y desplazamiento a la derecha (>>). El desplazamiento a la izquierda rellena con ceros. El desplazamiento a la derecha, si se trata de un dato con signo, mantiene el signo. Si no, rellena con ceros.

Operadores de Asignación: El operador básico de asignación es =. Además, tenemos las clásicas abreviaturas +=, -=, *=, /=, &=, |=, ^=, <<= y >>=

Estas abreviaturas se usan para evitar tecleo en operaciones como esta:

     variable1 = variable1 + variable2;

Se puede escribir de esta forma abreviada:

     variable1 += variable2;

También tenemos operadores de incremento (++) y decremento (--), que incrementan en una unidad el valor de la variable sobre la que se aplican. Por tanto, estas tres líneas de código son casi iguales:

     variable1 = variable1 + 1;

     variable1 += 1;

     variable1++;

El "casi iguales" lo ponemos porque en muchas máquinas, el operador ++ es más rápido que la operación "+ 1", ya que el compilador lo traduce a una única instrucción máquina.

Hay que tener en cuenta que no es lo mismo poner variable++ que ++variable. Ambas formas son correctas, pero no significan lo mismo. Lo vemos con un ejemplo:

     variable1 = ++variable2;

     variable1 = variable2++;

En el primer caso, primero se incrementa variable2 y luego se hace la asignación. En el segundo caso primero se hace la asignación, y luego el incremento.

Operador Condicional: Es el único operador de C# que tiene tres operandos. Su sintaxis es esta:

·              <condición> ? <expresión1> : <expresión2>

Quiere decir que si la condición es true, se evalúa expresión1, y si es falsa, se evalúa expresión2.
Ojo: No confundir con un "if". Este operador devuelve un valor, mientras que el if es sólamente una instrucción.

Operadores de Acceso a Objetos: El operador para acceder a los miembros de un objeto es el punto. Así esta expresión:

·              A.metodo1 ();

nos permite acceder al método "metodo1" del objeto A.

Operadores de Punteros: Tenemos varios operadores. Para acceder a la dirección de memoria a la que apunta el puntero, lo hacemos con &puntero. Para acceder al contenido de la dirección de memoria, tenemos *puntero. Si lo que referencia el puntero es un objeto, podemos acceder a sus miembros con puntero->miembro.

Operadores de Obtención de Información sobre Tipos: Para averiguar el tipo de una variable, usamos el operador sizeof(variable). Nos devolverá un objeto de tipo System.Type. Si queremos hacer una comparación, usamos algo como esto:

·              (expresion) is TIPO

que, como es lógico, nos devolverá un true o un false.

Operadores de Conversión: Para convertir el tipo de un objeto en otro, precedemos el objeto que queremos cambiar con el tipo al que queremos convertir, entre paréntesis, de esta forma:

·              variable1 = (int) variable2;

De esta forma, variable2 será tratada como si fuera un dato de tipo int, aunque no lo sea.

Veamos un ejemplo del uso de los operadores unarios:

using System;

class Operadores1 {

    public static void Main() {

        int unario = 0;

        int preIncremento;

        int preDecremento;

        int postIncremento;

        int postDecremento;

        sbyte bitNot;

        bool logNot;

        preIncremento = ++unario;

        Console.WriteLine("Pre-Incremento: {0}", preIncremento);

        preDecremento = --unario;

        Console.WriteLine("Pre-Decremento: {0}", preDecremento);

        postDecremento = unario--;

        Console.WriteLine("Post-Decremento: {0}", postDecremento);

        postIncremento = unario++;

        Console.WriteLine("Post-Incremento: {0}", postIncremento);

        Console.WriteLine("Valor final de unario: {0}", unario);

        bitNot = 0;

        bitNot = (sbyte)(~bitNot);

        Console.WriteLine("Negación a nivel de bit: {0}", bitNot);

        logNot = false;

        logNot = !logNot;

        Console.WriteLine("Negación lógica: {0}", logNot);

Otro ejemplo, ahora del uso de operadores binarios:

using System;

class Operadores2 {

    public static void Main() {

        int x,y,resultado;

        x = 7;

        y = 5;

        resultado = x + y;

        Console.WriteLine(" x+y = {0}", resultado);

        resultado = x - y;

        Console.WriteLine(" x-y = {0}", resultado);

        resultado = x * y;

        Console.WriteLine(" x*y = {0}", resultado);

        resultado = x / y;

        Console.WriteLine(" x/y = {0}", resultado);

Hasta ahora hemos visto programas muy simples con una serie de pasos secuenciales. En ellos no se comprueban valores para tomar decisiones, en función de las entradas, por ejemplo.

En esta sección vamos a estudiar las estructuras de control de C#, tanto las condicionales como los bucles.