C#-operators

In dit artikel zullen we alles leren over verschillende soorten operators in de programmeertaal C# en hoe u ze kunt gebruiken.

Operators zijn symbolen die worden gebruikt om bewerkingen op operanden uit te voeren. Operanden kunnen variabelen en/of constanten zijn.

Bijvoorbeeld , in 2+3 , + is een operator die wordt gebruikt om optellingen uit te voeren, terwijl 2 en 3 zijn operanden.

Operators worden gebruikt om variabelen en waarden in een programma te manipuleren. C# ondersteunt een aantal operators die zijn geclassificeerd op basis van het type bewerkingen dat ze uitvoeren.

1. Basistoewijzingsoperator

Basistoewijzingsoperator (=) wordt gebruikt om waarden aan variabelen toe te wijzen. Bijvoorbeeld,

double x;
x = 50.05;

Hier wordt 50.05 toegewezen aan x.

Voorbeeld 1:Basistoewijzingsoperator

using System;

namespace Operator
{
	class AssignmentOperator
	{
		public static void Main(string[] args)
		{
			int firstNumber, secondNumber;
			// Assigning a constant to variable
			firstNumber = 10;
			Console.WriteLine("First Number = {0}", firstNumber);

			// Assigning a variable to another variable
			secondNumber = firstNumber;
			Console.WriteLine("Second Number = {0}", secondNumber);
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

First Number = 10
Second Number = 10

Dit is een eenvoudig voorbeeld dat het gebruik van de toewijzingsoperator laat zien.

Je hebt misschien het gebruik van accolades { } opgemerkt in het voorbeeld. We zullen erover praten in tekenreeksopmaak . Houd er voorlopig rekening mee dat {0} wordt vervangen door de eerste variabele die volgt op de string, {1} wordt vervangen door de tweede variabele enzovoort.

2. Rekenkundige operatoren

Rekenkundige operatoren worden gebruikt om rekenkundige bewerkingen uit te voeren, zoals optellen, aftrekken, vermenigvuldigen, delen, enz.

Bijvoorbeeld,

int x = 5;
int y = 10;
int z = x + y;// z = 15

Voorbeeld 2:rekenkundige operatoren

using System;
 
namespace Operator
{
	class ArithmeticOperator
	{
		public static void Main(string[] args)
		{
			double firstNumber = 14.40, secondNumber = 4.60, result;
			int num1 = 26, num2 = 4, rem;

			// Addition operator
			result = firstNumber + secondNumber;
			Console.WriteLine("{0} + {1} = {2}", firstNumber, secondNumber, result);

			// Subtraction operator
			result = firstNumber - secondNumber;
			Console.WriteLine("{0} - {1} = {2}", firstNumber, secondNumber, result);

			// Multiplication operator
			result = firstNumber * secondNumber;
			Console.WriteLine("{0} * {1} = {2}", firstNumber, secondNumber, result);

			// Division operator
			result = firstNumber / secondNumber;
			Console.WriteLine("{0} / {1} = {2}", firstNumber, secondNumber, result);

			// Modulo operator
			rem = num1 % num2;
			Console.WriteLine("{0} % {1} = {2}", num1, num2, rem);
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

14.4 + 4.6 = 19
14.4 - 4.6 = 9.8
14.4 * 4.6 = 66.24
14.4 / 4.6 = 3.1304347826087
26 % 4 = 2

Rekenkundige bewerkingen worden uitgevoerd in het bovenstaande voorbeeld. Variabelen kunnen worden vervangen door constanten in de statements. Bijvoorbeeld,

result = 4.5 + 2.7 ; // result will hold 7.2
result = firstNumber - 3.2; // result will hold 11.2

3. Relationele operators

Relationele operatoren worden gebruikt om de relatie tussen twee operanden te controleren. Als de relatie waar is, is het resultaat true , anders resulteert dit in false .

Relationele operatoren worden gebruikt bij besluitvorming en lussen.

Voorbeeld 3:relationele operators

using System;
 
namespace Operator
{
	class RelationalOperator
	{
		public static void Main(string[] args)
		{
			bool result;
			int firstNumber = 10, secondNumber = 20;

			result = (firstNumber==secondNumber);
			Console.WriteLine("{0} == {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber > secondNumber);
			Console.WriteLine("{0} > {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber < secondNumber);
			Console.WriteLine("{0} < {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber >= secondNumber);
			Console.WriteLine("{0} >= {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber <= secondNumber);
			Console.WriteLine("{0} <= {1} returns {2}",firstNumber, secondNumber, result);

			result = (firstNumber != secondNumber);
			Console.WriteLine("{0} != {1} returns {2}",firstNumber, secondNumber, result);
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

10 == 20 returns False
10 > 20 returns False
10 < 20 returns True
10 >= 20 returns False
10 <= 20 returns True
10 != 20 returns True

4. Logische operators

Logische operators worden gebruikt om logische bewerkingen uit te voeren, zoals and , or . Logische operatoren werken op booleaanse uitdrukkingen (true en false ) en retourneert booleaanse waarden. Logische operatoren worden gebruikt bij besluitvorming en lussen.

Hier is hoe het resultaat wordt geëvalueerd voor logische AND en OR operators.

In eenvoudige bewoordingen kan de tabel worden samengevat als:

• Als een van de operanden waar is, de OR operator zal het evalueren tot true .
• Als een van de operanden onwaar is, de AND operator zal het evalueren tot false .

Voorbeeld 4:Logische operators

using System;
 
namespace Operator
{
	class LogicalOperator
	{
		public static void Main(string[] args)
		{
			bool result;
			int firstNumber = 10, secondNumber = 20;

			// OR operator
			result = (firstNumber == secondNumber) || (firstNumber > 5);
			Console.WriteLine(result);

			// AND operator
			result = (firstNumber == secondNumber) && (firstNumber > 5);
			Console.WriteLine(result);
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

True
False

5. Unaire operatoren

In tegenstelling tot andere operatoren werken de unaire operatoren op een enkele operand.

Voorbeeld 5:Unaire operatoren

using System;
 
namespace Operator
{
	class UnaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10, result;
			bool flag = true;

			result = +number;
			Console.WriteLine("+number = " + result);

			result = -number;
			Console.WriteLine("-number = " + result);

			result = ++number;
			Console.WriteLine("++number = " + result);

			result = --number;
			Console.WriteLine("--number = " + result);

			Console.WriteLine("!flag = " + (!flag));
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

+number = 10
-number = -10
++number = 11
--number = 10
!flag = False

De verhoging (++) en verlaag (--) operatoren kunnen als prefix en postfix worden gebruikt. Indien gebruikt als prefix, wordt de verandering in waarde van variabele gezien op dezelfde regel en indien gebruikt als postfix, wordt de verandering in waarde van variabele gezien op de volgende regel. Dit zal duidelijk worden door het onderstaande voorbeeld.

Voorbeeld 6:Post- en Pre-Increment-operators in C#

using System;
 
namespace Operator
{
	class UnaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;

			Console.WriteLine((number++));
			Console.WriteLine((number));

			Console.WriteLine((++number));
			Console.WriteLine((number));
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

10
11
12
12

We kunnen het effect zien van het gebruik van ++ als prefix en postfix. Wanneer ++ wordt gebruikt na de operand, wordt de waarde eerst geëvalueerd en vervolgens verhoogd met 1 . Vandaar de uitspraak

Console.WriteLine((number++));

drukt 10 af in plaats van 11 . Nadat de waarde is afgedrukt, wordt de waarde van het getal verhoogd met 1 .

Het proces is het tegenovergestelde wanneer ++ wordt gebruikt als voorvoegsel. De waarde wordt verhoogd voordat wordt afgedrukt. Vandaar de uitspraak

Console.WriteLine((++number));

drukt 12 af .

Hetzelfde geldt voor de decrement-operator (--) .

6. Ternaire operator

De ternaire operator ? : werkt op drie operanden. Het is een afkorting voor if-then-else uitspraak. De ternaire operator kan als volgt worden gebruikt:

variable = Condition? Expression1 : Expression2;

De ternaire operator werkt als volgt:

• Als de door Voorwaarde opgegeven uitdrukking true is , het resultaat van Expressie1 is toegewezen aan variabele.
• Als het false is , het resultaat van Expressie2 is toegewezen aan variabele.

Voorbeeld 7:ternaire operator

using System;
 
namespace Operator
{
	class TernaryOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;
			string result;

			result = (number % 2 == 0)? "Even Number" : "Odd Number";
			Console.WriteLine("{0} is {1}", number, result);
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

10 is Even Number

Ga voor meer informatie naar C# ternaire operator .

7. Bitsgewijze en bitverschuivingsoperators

Bitsgewijze en bitverschuivingsoperatoren worden gebruikt om bitmanipulatiebewerkingen uit te voeren.

Voorbeeld 8:bitsgewijze en bitverschuivingsoperator

using System;
 
namespace Operator
{
	class BitOperator
	{
		public static void Main(string[] args)
		{
			int firstNumber = 10;
			int secondNumber = 20;
			int result;

			result = ~firstNumber;
			Console.WriteLine("~{0} = {1}", firstNumber, result);

			result = firstNumber & secondNumber;
			Console.WriteLine("{0} & {1} = {2}", firstNumber,secondNumber, result);

			result = firstNumber | secondNumber;
			Console.WriteLine("{0} | {1} = {2}", firstNumber,secondNumber, result);

			result = firstNumber ^ secondNumber;
			Console.WriteLine("{0} ^ {1} = {2}", firstNumber,secondNumber, result);

			result = firstNumber << 2;
			Console.WriteLine("{0} << 2 = {1}", firstNumber, result);

			result = firstNumber >> 2;
			Console.WriteLine("{0} >> 2 = {1}", firstNumber, result);
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

~10 = -11
10 & 20 = 0
10 | 20 = 30
10 ^ 20 = 30
10 << 2 = 40
10 >> 2 = 2

Ga voor meer informatie naar C# Bitwise en Bit Shift-operator .

8. Samengestelde toewijzingsoperators

Voorbeeld 9:Samengestelde toewijzingsoperator

using System;
 
namespace Operator
{
	class BitOperator
	{
		public static void Main(string[] args)
		{
			int number = 10;

			number += 5;
			Console.WriteLine(number);

			number -= 3;
			Console.WriteLine(number);

			number *= 2;
			Console.WriteLine(number);

			number /= 3;
			Console.WriteLine(number);

			number %= 3;
			Console.WriteLine(number);

			number &= 10;
			Console.WriteLine(number);

			number |= 14;
			Console.WriteLine(number);

			number ^= 12;
			Console.WriteLine(number);

			number <<= 2;
			Console.WriteLine(number);

			number >>= 3;
			Console.WriteLine(number);
		}
	}
}

Wanneer we het programma uitvoeren, is de uitvoer:

15
12
24
8
2
2
14
2
8
1

We zullen het hebben over Lambda-operators in latere zelfstudie.