Los operadores son la base de cualquier lenguaje de programación. Por lo tanto, la funcionalidad del lenguaje C# está incompleta sin el uso de operadores. Los operadores nos permiten realizar diferentes tipos de operaciones en los operandos . En C# , los operadores se pueden clasificar en función de sus diferentes funciones :
- Operadores aritméticos
- Operadores relacionales
- Operadores logicos
- Operadores bit a bit
- Operadores de Asignación
- Operador Condicional
En C#, los operadores también pueden categorizarse según el número de operandos:
- Operador unario: Operador que toma un operando para realizar la operación.
- Operador Binario: Operador que toma dos operandos para realizar la operación.
- Operador Ternario: Operador que toma tres operandos para realizar la operación.
Operadores aritméticos
Estos se utilizan para realizar operaciones aritméticas/matemáticas en operandos. Los operadores binarios que caen en esta categoría son:
- Adición: el operador ‘+’ suma dos operandos. Por ejemplo, x+y .
- Resta: el operador ‘-‘ resta dos operandos. Por ejemplo, xy .
- Multiplicación: El operador ‘*’ multiplica dos operandos. Por ejemplo, x*y .
- División: El operador ‘/’ divide el primer operando por el segundo. Por ejemplo, x/y .
- Módulo: el operador ‘%’ devuelve el resto cuando el primer operando se divide por el segundo. Por ejemplo, x%y .
Ejemplo:
C#
// C# program to demonstrate the working
// of Binary Arithmetic Operators
using System;
namespace Arithmetic
{
class GFG
{
// Main Function
static void Main(string[] args)
{
int result;
int x = 10, y = 5;
// Addition
result = (x + y);
Console.WriteLine("Addition Operator: " + result);
// Subtraction
result = (x - y);
Console.WriteLine("Subtraction Operator: " + result);
// Multiplication
result = (x * y);
Console.WriteLine("Multiplication Operator: "+ result);
// Division
result = (x / y);
Console.WriteLine("Division Operator: " + result);
// Modulo
result = (x % y);
Console.WriteLine("Modulo Operator: " + result);
}
}
}
Producción:
Addition Operator: 15 Subtraction Operator: 5 Multiplication Operator: 50 Division Operator: 2 Modulo Operator: 0
Los que caen en la categoría de Operadores Unarios son:
- Incremento: el operador ‘++’ se utiliza para incrementar el valor de un número entero. Cuando se coloca antes del nombre de la variable (también llamado operador de preincremento ), su valor se incrementa instantáneamente. Por ejemplo, ++x .
Y cuando se coloca después del nombre de la variable (también llamado operador de incremento posterior ), su valor se conserva temporalmente hasta la ejecución de esta instrucción y se actualiza antes de la ejecución de la siguiente instrucción. Por ejemplo, x++ . - Decremento: El operador ‘–’ se utiliza para disminuir el valor de un número entero. Cuando se coloca antes del nombre de la variable (también llamado operador de decremento previo ), su valor se decrementa instantáneamente. Por ejemplo, –x .
Y cuando se coloca después del nombre de la variable (también llamado operador posterior al decremento ), su valor se conserva temporalmente hasta la ejecución de esta instrucción y se actualiza antes de la ejecución de la siguiente instrucción. Por ejemplo, x- .
Ejemplo:
C#
// C# program to demonstrate the working
// of Unary Arithmetic Operators
using System;
namespace Arithmetic {
class GFG {
// Main Function
static void Main(string[] args)
{
int a = 10, res;
// post-increment example:
// res is assigned 10 only,
// a is not updated yet
res = a++;
//a becomes 11 now
Console.WriteLine("a is {0} and res is {1}", a, res);
// post-decrement example:
// res is assigned 11 only, a is not updated yet
res = a--;
//a becomes 10 now
Console.WriteLine("a is {0} and res is {1}", a, res);
// pre-increment example:
// res is assigned 11 now since a
// is updated here itself
res = ++a;
// a and res have same values = 11
Console.WriteLine("a is {0} and res is {1}", a, res);
// pre-decrement example:
// res is assigned 10 only since
// a is updated here itself
res = --a;
// a and res have same values = 10
Console.WriteLine("a is {0} and res is {1}",a, res);
}
}
}
Producción:
a is 11 and res is 10 a is 10 and res is 11 a is 11 and res is 11 a is 10 and res is 10
Operadores relacionales
Los operadores relacionales se utilizan para comparar dos valores. Vamos a verlos uno por uno:
- El operador ‘=='(Igual a) comprueba si los dos operandos dados son iguales o no. Si es así, devuelve verdadero. De lo contrario devuelve falso. Por ejemplo, 5==5 devolverá verdadero.
- El operador ‘!='(No es igual a) comprueba si los dos operandos dados son iguales o no. Si no, devuelve verdadero. De lo contrario devuelve falso. Es el complemento booleano exacto del operador ‘==’ . Por ejemplo, 5!=5 devolverá falso.
- El operador ‘>'(Mayor que) comprueba si el primer operando es mayor que el segundo operando. Si es así, devuelve verdadero. De lo contrario devuelve falso. Por ejemplo, 6>5 devolverá verdadero.
- El operador ‘<‘(menor que) comprueba si el primer operando es menor que el segundo operando. Si es así, devuelve verdadero. De lo contrario devuelve falso. Por ejemplo, 6<5 devolverá falso.
- El operador ‘>='(Mayor que igual a) comprueba si el primer operando es mayor o igual que el segundo operando. Si es así, devuelve verdadero. De lo contrario devuelve falso. Por ejemplo, 5>=5 devolverá verdadero.
- El operador ‘<='(menor que igual a) comprueba si el primer operando es menor o igual que el segundo operando. Si es así, devuelve verdadero. De lo contrario devuelve falso. Por ejemplo, 5<=5 también devolverá verdadero.
Ejemplo:
C#
// C# program to demonstrate the working
// of Relational Operators
using System;
namespace Relational {
class GFG {
// Main Function
static void Main(string[] args)
{
bool result;
int x = 5, y = 10;
// Equal to Operator
result = (x == y);
Console.WriteLine("Equal to Operator: " + result);
// Greater than Operator
result = (x > y);
Console.WriteLine("Greater than Operator: " + result);
// Less than Operator
result = (x < y);
Console.WriteLine("Less than Operator: " + result);
// Greater than Equal to Operator
result = (x >= y);
Console.WriteLine("Greater than or Equal to: "+ result);
// Less than Equal to Operator
result = (x <= y);
Console.WriteLine("Lesser than or Equal to: "+ result);
// Not Equal To Operator
result = (x != y);
Console.WriteLine("Not Equal to Operator: " + result);
}
}
}
Producción:
Equal to Operator: False Greater than Operator: False Less than Operator: True Greater than or Equal to: False Lesser than or Equal to: True Not Equal to Operator: True
Operadores logicos
Se utilizan para combinar dos o más condiciones/restricciones o para complementar la evaluación de la condición original en consideración. Se describen a continuación:
- Y lógico: el operador ‘&&’ devuelve verdadero cuando se cumplen las dos condiciones consideradas. De lo contrario devuelve falso. Por ejemplo, a && b devuelve verdadero cuando tanto a como b son verdaderos (es decir, distintos de cero).
- OR lógico: el ‘||’ El operador devuelve verdadero cuando se cumple una (o ambas) de las condiciones en consideración. De lo contrario devuelve falso. Por ejemplo, un || b devuelve verdadero si uno de a o b es verdadero (es decir, distinto de cero). Por supuesto, devuelve verdadero cuando tanto a como b son verdaderos.
- NO Lógico: El ‘!’ operador devuelve verdadero la condición en consideración no se cumple. De lo contrario devuelve falso. Por ejemplo, !a devuelve verdadero si a es falso, es decir, cuando a=0.
Ejemplo:
C#
// C# program to demonstrate the working
// of Logical Operators
using System;
namespace Logical {
class GFG {
// Main Function
static void Main(string[] args)
{
bool a = true,b = false, result;
// AND operator
result = a && b;
Console.WriteLine("AND Operator: " + result);
// OR operator
result = a || b;
Console.WriteLine("OR Operator: " + result);
// NOT operator
result = !a;
Console.WriteLine("NOT Operator: " + result);
}
}
}
Producción:
AND Operator: False OR Operator: True NOT Operator: False
Operadores bit a bit
En C#, hay 6 operadores bit a bit que funcionan a nivel de bit o se utilizan para realizar operaciones bit a bit. Los siguientes son los operadores bit a bit:
- & (Y bit a bit) Toma dos números como operandos y hace AND en cada bit de dos números. El resultado de AND es 1 solo si ambos bits son 1.
- | (OR bit a bit) Toma dos números como operandos y hace OR en cada bit de dos números. El resultado de OR es 1 cualquiera de los dos bits es 1.
- ^ (XOR bit a bit) Toma dos números como operandos y hace XOR en cada bit de dos números. El resultado de XOR es 1 si los dos bits son diferentes.
- << (desplazamiento a la izquierda) Toma dos números, desplaza a la izquierda los bits del primer operando, el segundo operando decide el número de lugares a desplazar.
- >> (desplazamiento a la derecha) Toma dos números, desplaza a la derecha los bits del primer operando, el segundo operando decide el número de lugares a desplazar.
Ejemplo:
C#
// C# program to demonstrate the working
// of Bitwise Operators
using System;
namespace Bitwise {
class GFG {
// Main Function
static void Main(string[] args)
{
int x = 5, y = 10, result;
// Bitwise AND Operator
result = x & y;
Console.WriteLine("Bitwise AND: " + result);
// Bitwise OR Operator
result = x | y;
Console.WriteLine("Bitwise OR: " + result);
// Bitwise XOR Operator
result = x ^ y;
Console.WriteLine("Bitwise XOR: " + result);
// Bitwise AND Operator
result = ~x;
Console.WriteLine("Bitwise Complement: " + result);
// Bitwise LEFT SHIFT Operator
result = x << 2;
Console.WriteLine("Bitwise Left Shift: " + result);
// Bitwise RIGHT SHIFT Operator
result = x >> 2;
Console.WriteLine("Bitwise Right Shift: " + result);
}
}
}
Producción:
Bitwise AND: 0 Bitwise OR: 15 Bitwise XOR: 15 Bitwise Complement: -6 Bitwise Left Shift: 20 Bitwise Right Shift: 1
Operadores de Asignación
Los operadores de asignación se utilizan para asignar un valor a una variable. El operando del lado izquierdo del operador de asignación es una variable y el operando del lado derecho del operador de asignación es un valor. El valor del lado derecho debe ser del mismo tipo de datos que la variable del lado izquierdo; de lo contrario, el compilador generará un error.
A continuación se muestran diferentes tipos de operadores de asignación:
- “=”(Asignación Simple) : Este es el operador de asignación más simple. Este operador se utiliza para asignar el valor de la derecha a la variable de la izquierda.
Ejemplo:
a = 10; b = 20; ch = 'y';
- “+=”(Agregar asignación) : este operador es una combinación de los operadores ‘+’ y ‘=’. Este operador primero suma el valor actual de la variable de la izquierda al valor de la derecha y luego asigna el resultado a la variable de la izquierda.
Ejemplo:
(a += b) can be written as (a = a + b)
Si inicialmente el valor almacenado en a es 5. Entonces (a += 6) = 11.
- “-=”(Restar asignación) : este operador es una combinación de los operadores ‘-‘ y ‘=’. Este operador primero resta el valor actual de la variable de la izquierda del valor de la derecha y luego asigna el resultado a la variable de la izquierda.
Ejemplo:
(a -= b) can be written as (a = a - b)
Si inicialmente el valor almacenado en a es 8. Entonces (a -= 6) = 2.
- “*=”(Multiplicar asignación) : este operador es una combinación de los operadores ‘*’ y ‘=’. Este operador primero multiplica el valor actual de la variable de la izquierda por el valor de la derecha y luego asigna el resultado a la variable de la izquierda.
Ejemplo:
(a *= b) can be written as (a = a * b)
Si inicialmente el valor almacenado en a es 5. Entonces (a *= 6) = 30.
- “/=”(asignación de división): este operador es una combinación de los operadores ‘/’ y ‘=’. Este operador primero divide el valor actual de la variable de la izquierda por el valor de la derecha y luego asigna el resultado a la variable de la izquierda.
Ejemplo:
(a /= b) can be written as (a = a / b)
Si inicialmente el valor almacenado en a es 6. Entonces (a /= 2) = 3.
- “%=”(Asignación de módulo): Este operador es una combinación de los operadores ‘%’ y ‘=’. Este operador primero modula el valor actual de la variable de la izquierda por el valor de la derecha y luego asigna el resultado a la variable de la izquierda.
Ejemplo:
(a %= b) can be written as (a = a % b)
Si inicialmente el valor almacenado en a es 6. Entonces (a %= 2) = 0.
- “<<=”(Asignación de desplazamiento a la izquierda) : este operador es una combinación de los operadores ‘<<‘ y ‘=’. Este operador primero desplaza a la izquierda el valor actual de la variable de la izquierda por el valor de la derecha y luego asigna el resultado a la variable de la izquierda.
Ejemplo:
(a <<= 2) can be written as (a = a << 2)
Si inicialmente el valor almacenado en a es 6. Entonces (a <<= 2) = 24.
- “>>=”(Asignación de desplazamiento a la derecha) : este operador es una combinación de los operadores ‘>>’ y ‘=’. Este operador primero desplaza a la derecha el valor actual de la variable de la izquierda por el valor de la derecha y luego asigna el resultado a la variable de la izquierda.
Ejemplo:
(a >>= 2) can be written as (a = a >> 2)
Si inicialmente el valor almacenado en a es 6. Entonces (a >>= 2) = 1.
- “&=”(Asignación AND bit a bit) : Este operador es una combinación de los operadores ‘&’ y ‘=’. Este operador primero «Y bit a bit» el valor actual de la variable de la izquierda por el valor de la derecha y luego asigna el resultado a la variable de la izquierda.
Ejemplo:
(a &= 2) can be written as (a = a & 2)
Si inicialmente el valor almacenado en a es 6, entonces (a &= 2) = 2.
- “^=”(O exclusivo bit a bit) : este operador es una combinación de los operadores ‘^’ y ‘=’. Este operador primero «OR exclusivo bit a bit» el valor actual de la variable de la izquierda por el valor de la derecha y luego asigna el resultado a la variable de la izquierda.
Ejemplo:
(a ^= 2) can be written as (a = a ^ 2)
Si inicialmente el valor almacenado en a es 6. Entonces (a ^= 2) = 4.
- “|=”(Bitwise Inclusive OR) : Este operador es una combinación de ‘|’ y operadores ‘=’. Este operador primero «O bit a bit inclusivo» el valor actual de la variable de la izquierda por el valor de la derecha y luego asigna el resultado a la variable de la izquierda.
Ejemplo :
(a |= 2) can be written as (a = a | 2)
Si inicialmente, el valor almacenado en a es 6. Entonces (a |= 2) = 6.
Ejemplo:
C#
// C# program to demonstrate the working
// of Assignment Operators
using System;
namespace Assignment {
class GFG {
// Main Function
static void Main(string[] args)
{
// initialize variable x
// using Simple Assignment
// Operator "="
int x = 15;
// it means x = x + 10
x += 10;
Console.WriteLine("Add Assignment Operator: " + x);
// initialize variable x again
x = 20;
// it means x = x - 5
x -= 5;
Console.WriteLine("Subtract Assignment Operator: " + x);
// initialize variable x again
x = 15;
// it means x = x * 5
x *= 5;
Console.WriteLine("Multiply Assignment Operator: " + x);
// initialize variable x again
x = 25;
// it means x = x / 5
x /= 5;
Console.WriteLine("Division Assignment Operator: " + x);
// initialize variable x again
x = 25;
// it means x = x % 5
x %= 5;
Console.WriteLine("Modulo Assignment Operator: " + x);
// initialize variable x again
x = 8;
// it means x = x << 2
x <<= 2;
Console.WriteLine("Left Shift Assignment Operator: " + x);
// initialize variable x again
x = 8;
// it means x = x >> 2
x >>= 2;
Console.WriteLine("Right Shift Assignment Operator: " + x);
// initialize variable x again
x = 12;
// it means x = x >> 4
x &= 4;
Console.WriteLine("Bitwise AND Assignment Operator: " + x);
// initialize variable x again
x = 12;
// it means x = x >> 4
x ^= 4;
Console.WriteLine("Bitwise Exclusive OR Assignment Operator: " + x);
// initialize variable x again
x = 12;
// it means x = x >> 4
x |= 4;
Console.WriteLine("Bitwise Inclusive OR Assignment Operator: " + x);
}
}
}
Producción :
Add Assignment Operator: 25 Subtract Assignment Operator: 15 Multiply Assignment Operator: 75 Division Assignment Operator: 5 Modulo Assignment Operator: 0 Left Shift Assignment Operator: 32 Right Shift Assignment Operator: 2 Bitwise AND Assignment Operator: 4 Bitwise Exclusive OR Assignment Operator: 8 Bitwise Inclusive OR Assignment Operator: 12
Operador Condicional
Es un operador ternario que es una versión abreviada de la declaración if-else. Tiene tres operandos y de ahí el nombre ternario. Devolverá uno de dos valores dependiendo del valor de una expresión booleana.
Sintaxis:
condition ? first_expression : second_expression;
Explicación:
condición: Debe evaluarse como verdadero o falso.
Si la condición es verdadera
, se evalúa first_expression y se convierte en el resultado.
Si la condición es falsa,
se evalúa second_expression y se convierte en el resultado.
Ejemplo:
C#
// C# program to demonstrate the working
// of Conditional Operator
using System;
namespace Conditional {
class GFG {
// Main Function
static void Main(string[] args)
{
int x = 5, y = 10, result;
// To find which value is greater
// Using Conditional Operator
result = x > y ? x : y;
// To display the result
Console.WriteLine("Result: " + result);
// To find which value is greater
// Using Conditional Operator
result = x < y ? x : y;
// To display the result
Console.WriteLine("Result: " + result);
}
}
}
Producción :
Result: 10 Result: 5
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA