C# Operadores

Un operador es un símbolo que le indica al compilador realizar operaciones matemáticas o lógicas específicas. C# tiene una rica variedad de operadores integrados, clasificados de la siguiente manera:

Operadores aritméticos
Operadores relacionales
Operadores lógicos
Operadores bit a bit
Operadores de asignación
Otros operadores

Este tutorial explicará uno a uno los operadores aritméticos, relacionales, lógicos, bit a bit, de asignación y otros operadores.

Operadores aritméticos

La siguiente tabla muestra todos los operadores aritméticos admitidos por C#. Supongamos que la variableAtiene el valor 10, y la variableBtiene el valor 20, entonces:

Operador	Descripción	Ejemplo
+	Suma los dos operandos	A + B dará 30
-	Resta el segundo operando del primer operando	A - B dará -10
*	Multiplica los dos operandos	A * B dará 200
/	Divide el numerador por el denominador	B / A dará 2
%	Operador de módulo, el resto después de la división entera	B % A dará 0
++	Operador de incremento, aumenta el valor entero en 1	A++ dará 11
--	Operador de decremento, disminuye el valor entero en 1	A-- dará 9

Ejemplo

Vea el siguiente ejemplo para comprender todos los operadores aritméticos disponibles en C#:

Ejemplo

using System;

namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
int a = 21;
int b = 10;
int c;

c = a + b;
Console.WriteLine("Línea 1 - el valor de c es {0}", c);
c = a - b;
Console.WriteLine("Línea 2 - el valor de c es {0}", c);
c = a * b;
Console.WriteLine("Línea 3 - el valor de c es {0}", c);
c = a / b;
Console.WriteLine("Línea 4 - el valor de c es {0}", c);
c = a % b;
Console.WriteLine("Línea 5 - el valor de c es {0}", c);

// ++a primero realiza el incremento y luego asigna
c = ++a;
Console.WriteLine("Línea 6 - el valor de c es {0}", c);

// en este momento el valor de a es 22
// --a primero realiza el decremento y luego asigna
c = --a;
Console.WriteLine("Línea 7 - el valor de c es {0}", c);
Console.ReadLine();
}
}
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Line 1 - c 的值是 31
Line 2 - c 的值是 11
Line 3 - c 的值是 210
Line 4 - c 的值是 2
Line 5 - c 的值是 1
Line 6 - c 的值是 22
Line 7 - c 的值是 21

c = a++: primero asigna a a c, y luego incrementa a.
c = ++a: primero incrementa a, y luego asigna a a c.
c = a--: primero asigna a a c, y luego decrementa a.
c = --a: primero decrementa a, y luego asigna a a c.

Ejemplo

using System;

namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
int a = 1;
int b;

// a++ primero asigna y luego realiza el incremento
b = a++;
Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
Console.ReadLine();

// ++a primero realiza el incremento y luego asigna
a = 1; // reinicializa a
b = ++a;
Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
Console.ReadLine();

// a-- primero asigna y luego realiza el decremento
a = 1; // reinicializa a
b= a--;
Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
Console.ReadLine();

// --a primero realiza el decremento y luego asigna
a = 1; // reinicializa a
b= --a;
Console.WriteLine("a = {0}", a);
Console.WriteLine("b = {0}", b);
Console.ReadLine();
}
}
}

Al ejecutar el programa anterior, el resultado es:

a = 2
b = 1
a = 2
b = 2
a = 0
b = 1
a = 0
b = 0

Operadores relacionales

La siguiente tabla muestra todos los operadores relacionales admitidos por C#. Supongamos que la variableAtiene el valor 10, y la variableBtiene el valor 20, entonces:

Operador	Descripción	Ejemplo
==	Comprueba si los valores de dos operandos son iguales; si lo son, la condición es verdadera.	(A == B) no es verdadero.
!=	Comprueba si los valores de dos operandos son iguales; si no lo son, la condición es verdadera.	(A != B) es verdadero.
>	Comprueba si el valor del operando izquierdo es mayor que el del derecho; si es así, la condición es verdadera.	(A > B) no es verdadero.
<	Comprueba si el valor del operando izquierdo es menor que el del derecho; si es así, la condición es verdadera.	(A < B) es verdadero.
>=	Comprueba si el valor del operando izquierdo es mayor o igual que el del derecho; si es así, la condición es verdadera.	(A >= B) no es verdadero.
<=	Comprueba si el valor del operando izquierdo es menor o igual que el del derecho; si es así, la condición es verdadera.	(A <= B) es verdadero.

Ejemplo

Vea el siguiente ejemplo para comprender todos los operadores relacionales disponibles en C#:

Ejemplo

using System;

class Program
{
static void Main(string[] args)
{
int a = 21;
int b = 10;

if (a == b)
{
Console.WriteLine("Línea 1 - a es igual a b");
}
else
{
Console.WriteLine("Línea 1 - a no es igual a b");
}
if (a < b)
{
Console.WriteLine("Línea 2 - a es menor que b");
}
else
{
Console.WriteLine("Línea 2 - a no es menor que b");
}
if (a > b)
{
Console.WriteLine("Línea 3 - a es mayor que b");
}
else
{
Console.WriteLine("Línea 3 - a no es mayor que b");
}
/* cambiar los valores de a y b */
a = 5;
b = 20;
if (a <= b)
{
Console.WriteLine("Línea 4 - a es menor o igual que b");
}
if (b >= a)
{
Console.WriteLine("Línea 5 - b es mayor o igual que a");
}
}
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Line 1 - a 不等于 b
Line 2 - a 不小于 b
Line 3 - a 大于 b
Line 4 - a 小于或等于 b
Line 5 - b 大于或等于 a

Operadores lógicos

La siguiente tabla muestra todos los operadores lógicos admitidos por C#. Supongamos que la variableAes el valor booleano true, y la variableBes el valor booleano false, entonces:

Operador	Descripción	Ejemplo
&&	Se llama operador AND lógico. Si ambos operandos son distintos de cero, la condición es verdadera.	(A && B) es falso.
\|\|	Se llama operador OR lógico. Si cualquiera de los dos operandos es distinto de cero, la condición es verdadera.	(A \|\| B) es verdadero.
!	Se llama operador NOT lógico. Se usa para invertir el estado lógico del operando. Si la condición es verdadera, el operador NOT lógico la hará falsa.	!(A && B) es verdadero.

Ejemplo

Vea el siguiente ejemplo para comprender todos los operadores lógicos disponibles en C#:

Ejemplo

using System;

namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
bool a = true;
bool b = true;

if (a && b)
{
Console.WriteLine("Línea 1 - la condición es verdadera");
}
if (a || b)
{
Console.WriteLine("Línea 2 - la condición es verdadera");
}
/* cambiar los valores de a y b */
a = false;
b = true;
if (a && b)
{
Console.WriteLine("Línea 3 - la condición es verdadera");
}
else
{
Console.WriteLine("Línea 3 - la condición no es verdadera");
}
if (!(a && b))
{
Console.WriteLine("Línea 4 - la condición es verdadera");
}
Console.ReadLine();
}
}
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Line 1 - 条件为真
Line 2 - 条件为真
Line 3 - 条件不为真
Line 4 - 条件为真

Operadores bit a bit

Los operadores bit a bit operan sobre bits y realizan operaciones bit por bit. La tabla de verdad de &, | y ^ es la siguiente:

p	q	p & q	p \| q	p ^ q
0	0	0	0	0
0	1	0	1	1
1	1	1	1	0
1	0	0	1	1

Supongamos que si A = 60 y B = 13, ahora representados en formato binario, son los siguientes:

A = 0011 1100

B = 0000 1101

-----------------

A&B = 0000 1100

A|B = 0011 1101

A^B = 0011 0001

~A = 1100 0011

La siguiente tabla enumera los operadores bit a bit admitidos por C#. Supongamos que la variableAtiene el valor 60, y la variableBtiene el valor 13, entonces:

Operador	Descripción	Ejemplo
&	Si el bit existe en ambos operandos, el operador AND binario copia un bit al resultado.	(A & B) dará 12, es decir 0000 1100
\|	Si el bit existe en cualquiera de los operandos, el operador OR binario copia un bit al resultado.	(A \| B) dará 61, es decir 0011 1101
^	Si el bit existe en uno de los operandos pero no en ambos, el operador XOR binario copia un bit al resultado.	(A ^ B) dará 49, es decir 0011 0001
~	El operador de complemento bit a bit es un operador unario que tiene el efecto de "voltear" los bits, es decir, 0 se convierte en 1 y 1 se convierte en 0, incluido el bit de signo.	(~A) dará -61, es decir 1100 0011, la forma de complemento a dos de un número binario con signo.
<<	Operador de desplazamiento a la izquierda binario. El valor del operando izquierdo se desplaza a la izquierda el número de bits especificado por el operando derecho.	A << 2 dará 240, es decir 1111 0000
>>	Operador de desplazamiento a la derecha binario. El valor del operando izquierdo se desplaza a la derecha la cantidad de bits especificada por el operando derecho.	A >> 2 dará 15, es decir, 0000 1111

Ejemplo

Consulte el siguiente ejemplo para conocer todos los operadores de bits disponibles en C#:

Ejemplo

using System;
namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
int a = 60; /* 60 = 0011 1100 */
int b = 13; /* 13 = 0000 1101 */
int c = 0;

c = a & b; /* 12 = 0000 1100 */
Console.WriteLine("Line 1 - el valor de c es {0}", c );

c = a | b; /* 61 = 0011 1101 */
Console.WriteLine("Line 2 - el valor de c es {0}", c);

c = a ^ b; /* 49 = 0011 0001 */
Console.WriteLine("Line 3 - el valor de c es {0}", c);

c = ~a; /*-61 = 1100 0011 */
Console.WriteLine("Line 4 - el valor de c es {0}", c);

c = a << 2; /* 240 = 1111 0000 */
Console.WriteLine("Line 5 - el valor de c es {0}", c);

c = a >> 2; /* 15 = 0000 1111 */
Console.WriteLine("Line 6 - el valor de c es {0}", c);
Console.ReadLine();
}
}
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Line 1 - c 的值是 12
Line 2 - c 的值是 61
Line 3 - c 的值是 49
Line 4 - c 的值是 -61
Line 5 - c 的值是 240
Line 6 - c 的值是 15

Operadores de asignación

La siguiente tabla enumera los operadores de asignación compatibles con C#:

Operador	Descripción	Ejemplo
=	Operador de asignación simple, asigna el valor del operando derecho al operando izquierdo.	C = A + B asignará el valor de A + B a C.
+=	Operador de suma y asignación, asigna al operando izquierdo el resultado de sumar el operando derecho al operando izquierdo.	C += A es equivalente a C = C + A.
-=	Operador de resta y asignación, asigna al operando izquierdo el resultado de restar el operando derecho del operando izquierdo.	C -= A es equivalente a C = C - A.
*=	Operador de multiplicación y asignación, asigna al operando izquierdo el resultado de multiplicar el operando derecho por el operando izquierdo.	C = A es equivalente a C = C A.
/=	Operador de división y asignación, asigna al operando izquierdo el resultado de dividir el operando izquierdo entre el operando derecho.	C /= A es equivalente a C = C / A.
%=	Operador de módulo y asignación, asigna al operando izquierdo el módulo de los dos operandos.	C %= A es equivalente a C = C % A.
<<=	Operador de desplazamiento a la izquierda y asignación.	C <<= 2 es equivalente a C = C << 2.
>>=	Operador de desplazamiento a la derecha y asignación.	C >>= 2 es equivalente a C = C >> 2.
&=	Operador de Y bit a bit y asignación.	C &= 2 es equivalente a C = C & 2.
^=	Operador de XOR bit a bit y asignación.	C ^= 2 es equivalente a C = C ^ 2.
\|=	Operador de O bit a bit y asignación.	C \|= 2 es equivalente a C = C \| 2.

Ejemplo

Consulte el siguiente ejemplo para conocer todos los operadores de asignación disponibles en C#:

Ejemplo

using System;

namespace OperatorsAppl
{
class Program
{
static void Main(string[] args)
{
int a = 21;
int c;

c = a;
Console.WriteLine("Line 1 - = el valor de c = {0}", c);

c += a;
Console.WriteLine("Line 2 - += el valor de c = {0}", c);

c -= a;
Console.WriteLine("Line 3 - -= el valor de c = {0}", c);

c *= a;
Console.WriteLine("Line 4 - *= el valor de c = {0}", c);

c /= a;
Console.WriteLine("Line 5 - /= el valor de c = {0}", c);

c = 200;
c %= a;
Console.WriteLine("Line 6 - %= el valor de c = {0}", c);

c <<= 2;
Console.WriteLine("Line 7 - <<= el valor de c = {0}", c);

c >>= 2;
Console.WriteLine("Line 8 - >>= el valor de c = {0}", c);

c &= 2;
Console.WriteLine("Line 9 - &= el valor de c = {0}", c);

c ^= 2;
Console.WriteLine("Line 10 - ^= el valor de c = {0}", c);

c |= 2;
Console.WriteLine("Line 11 - |= el valor de c = {0}", c);
Console.ReadLine();
}
}
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Line 1 - =     c 的值 = 21
Line 2 - +=    c 的值 = 42
Line 3 - -=    c 的值 = 21
Line 4 - *=    c 的值 = 441
Line 5 - /=    c 的值 = 21
Line 6 - %=    c 的值 = 11
Line 7 - <<=    c 的值 = 44
Line 8 - >>=    c 的值 = 11
Line 9 - &=    c 的值 = 2
Line 10 - ^=    c 的值 = 0
Line 11 - |=    c 的值 = 2

Otros operadores

La siguiente tabla enumera algunos otros operadores importantes compatibles con C#, incluyendo:sizeof、typeofy? :。

Operador	Descripción	Ejemplo
sizeof()	Devuelve el tamaño de un tipo de datos.	sizeof(int), devolverá 4.
typeof()	Devuelve el tipo de una clase.	typeof(StreamReader);
&	Devuelve la dirección de una variable.	&a; obtendrá la dirección real de la variable.
*	Puntero a una variable.	*a; apuntará a una variable.
? :	Expresión condicional	Si la condición es verdadera ? entonces X : de lo contrario Y
is	Determina si un objeto es de un tipo determinado.	If( Ford is Car) // comprueba si Ford es un objeto de la clase Car.
as	Conversión forzada, no lanza una excepción incluso si la conversión falla.	Object obj = new StringReader("Hello"); StringReader r = obj as StringReader;

Ejemplo

using System;

namespace OperatorsAppl
{

class Program
{
static void Main(string[] args)
{

/* Ejemplo del operador sizeof */
Console.WriteLine("El tamaño de int es {0}", sizeof(int));
Console.WriteLine("El tamaño de short es {0}", sizeof(short));
Console.WriteLine("El tamaño de double es {0}", sizeof(double));

/* Ejemplo del operador ternario */
int a, b;
a = 10;
b = (a == 1) ? 20 : 30;
Console.WriteLine("El valor de b es {0}", b);

b = (a == 10) ? 20 : 30;
Console.WriteLine("El valor de b es {0}", b);
Console.ReadLine();
}
}
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

int 的大小是 4
short 的大小是 2
double 的大小是 8
b 的值是 30
b 的值是 20

La palabra clave typeof se utiliza para obtener el objeto de tipo de un tipo; normalmente se usa para la reflexión y para crear dinámicamente instancias de tipos.

A continuación se muestra un ejemplo sencillo del uso de typeof:

Ejemplo

using System;

class Program
{
static void Main(string[] args)
{
Type type = typeof(string);
Console.WriteLine(type.FullName);
Console.ReadKey();
}
}

En el código anterior, usamos la palabra clave typeof para obtener el objeto de tipo del tipo string y lo almacenamos en la variable type de tipo Type. Luego, usamos la propiedad FullName para imprimir el nombre completo del tipo.

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

System.String

Precedencia de operadores en C#

La precedencia de operadores determina la combinación de términos en una expresión. Esto afecta a cómo se evalúa una expresión. Algunos operadores tienen mayor precedencia que otros; por ejemplo, los operadores de multiplicación y división tienen mayor precedencia que los de suma y resta.

Por ejemplo, x = 7 + 3 * 2; aquí, a x se le asigna 13, no 20, porque el operador * tiene mayor precedencia que +, por lo que primero se calcula la multiplicación 3*2 y luego se suma 7.

La siguiente tabla enumera los operadores por precedencia de mayor a menor. Los operadores con mayor precedencia aparecen en la parte superior de la tabla, y los de menor precedencia en la parte inferior. En una expresión, los operadores con mayor precedencia se evalúan primero.

Resumen simple de precedenciaPrimero los paréntesis, luego multiplicación/división y suma/resta, después desplazamientos y relaciones, luego lógicos, después condicionales y por último la coma., 。

Categoría	Operador	Asociatividad
Sufijo	() [] -> . ++ - -	De izquierda a derecha
Unario	+ - ! ~ ++ - - (type)* & sizeof	De derecha a izquierda
Multiplicación/división	* / %	De izquierda a derecha
Suma/resta	+ -	De izquierda a derecha
Desplazamiento	<< >>	De izquierda a derecha
Relacional	< <= > >=	De izquierda a derecha
Igualdad	== !=	De izquierda a derecha
Y bit a bit (AND)	&	De izquierda a derecha
XOR bit a bit	^	De izquierda a derecha
O bit a bit (OR)	\|	De izquierda a derecha
Y lógico (AND)	&&	De izquierda a derecha
O lógico (OR)	\|\|	De izquierda a derecha
Condicional	?:	De derecha a izquierda
Asignación	= += -= *= /= %=>>= <<= &= ^= \|=	De derecha a izquierda
Coma	,	De izquierda a derecha

Ejemplo

using System;

namespace OperatorsAppl
{

class Program
{
static void Main(string[] args)
{
int a = 20;
int b = 10;
int c = 15;
int d = 5;
int e;
e = (a + b) * c / d; // ( 30 * 15 ) / 5
Console.WriteLine("El valor de (a + b) * c / d es {0}", e);

e = ((a + b) * c) / d; // (30 * 15 ) / 5
Console.WriteLine("El valor de ((a + b) * c) / d es {0}", e);

e = (a + b) * (c / d); // (30) * (15/5)
Console.WriteLine("El valor de (a + b) * (c / d) es {0}", e);

e = a + (b * c) / d; // 20 + (150/5)
Console.WriteLine("El valor de a + (b * c) / d es {0}", e);
Console.ReadLine();
}
}
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

(a + b) * c / d 的值是 90
((a + b) * c) / d 的值是 90
(a + b) * (c / d) 的值是 90
a + (b * c) / d 的值是 50

Precedencia de los operadores aritméticos y de asignación:

Ejemplo

int a = 10, b = 5, c = 2;
int result = a + b * c; // Primero se calcula la multiplicación, luego la suma.
Console.WriteLine(result); // Imprime 20

result = (a + b) * c; // Primero se calcula la suma, luego la multiplicación.
Console.WriteLine(result); // Imprime 30

a += b * c; // Primero se calcula la multiplicación, luego se ejecuta la asignación con suma.
Console.WriteLine(a); // Imprime 20

Precedencia de los operadores lógicos:

Ejemplo

bool a = true, b = false, c = true;
bool result = a || b && c; // Primero se calcula la operación Y, luego la operación O.
Console.WriteLine(result); // Imprime true

result = (a || b) && c; // Primero se calcula la operación O, luego la operación Y.
Console.WriteLine(result); // Imprime true

result = a || (b && c); // Primero se calcula la operación Y, luego la operación O.
Console.WriteLine(result); // Imprime true

Precedencia del operador condicional:

Ejemplo

int a = 10, b = 5;
string result = a > b ? "a es mayor que b" : "a no es mayor que b"; // Primero se evalúa la relación de tamaño, luego se ejecuta la sentencia condicional.
Console.WriteLine(result); // Salida "a es mayor que b"

Nota:Debido a que los paréntesis pueden cambiar la precedencia de los operadores, en la práctica se recomienda usar paréntesis tanto como sea posible para aclarar el orden de las operaciones, mejorando la legibilidad y precisión del código.

Otras extensiones

C#Tutorial avanzado

C# Operadores

Operadores aritméticos

Ejemplo

Ejemplo

Ejemplo

Operadores relacionales

Ejemplo

Ejemplo

Operadores lógicos

Ejemplo

Ejemplo

Operadores bit a bit

Ejemplo

Ejemplo

Operadores de asignación

Ejemplo

Ejemplo

Otros operadores

Ejemplo

Ejemplo

Ejemplo

Precedencia de operadores en C#

Ejemplo

Ejemplo

Ejemplo

Ejemplo

Ejemplo