Wiskundige bewerkingen uitvoeren

Voltooid

Tip

Zie het tabblad Tekst en afbeeldingen voor meer informatie.

In hun kern zijn computers ongelooflijk snelle rekenmachines. C# ondersteunt alle standaardberekeningen die u zou verwachten, zodat u berekeningen kunt uitvoeren en de resultaten in variabelen kunt opslaan.

Rekenkundige operatoren

C# gebruikt standaardsymbolen voor basisberekeningen:

Operator	Action	Example	Result
+	Addition	10 + 3	13
-	Subtraction	10 - 3	7
*	Multiplication	10 * 3	30
/	Division	10 / 3	3 (deling van gehele getallen)
%	Modulo (rest)	10 % 3	1

U kunt deze code zelf uitvoeren in de C#-code-editor.

Modulus begrijpen (%)

De modulusoperator % retourneert wat er na deling overblijft. Het is handig om te controleren of een getal gelijkmatig wordt verdeeld:

Console.WriteLine(10 % 2);   // Output: 0 (10 is even)
Console.WriteLine(11 % 2);   // Output: 1 (11 is odd)

Volgorde van bewerkingen

C# volgt de standaard wiskundige volgorde van bewerkingen (PEMDAS): haakjes, vervolgens vermenigvuldigen/delen, en vervolgens optellen/aftrekken. Gebruik haakjes om de volgorde te bepalen:

int standard = 2 + 3 * 4;      // Multiplication first: 14
int forced = (2 + 3) * 4;      // Parentheses first: 20

Operatoren voor samengestelde toewijzing

Een veelvoorkomend patroon is het bijwerken van een variabele met een eigen waarde, zoals het toevoegen aan een score of het aftrekken van een saldo. C# heeft hiervoor verkorte operatoren:

int score = 50;
score = score + 10;    // Standard way: score is 60
score += 10;           // Shorthand: score is 70

Dezelfde verkorte notatie geldt ook voor andere bewerkingen:

Operator	Meaning	Example	Resultaat (beginnend bij 10)
+=	Toevoegen en toewijzen	x += 5	15
-=	Aftrekken en toewijzen	x -= 5	5
*=	Vermenigvuldigen en toewijzen	x *= 5	50
/=	Delen en toewijzen	x /= 5	2

Operatoren voor incrementeer en decrementeer

Voor het optellen of aftrekken 1heeft C# nog kortere operatoren,++ en --:

int count = 5;
count++;                       // Same as count = count + 1
Console.WriteLine(count);      // Output: 6

count--;                       // Same as count = count - 1
Console.WriteLine(count);      // Output: 5

Positie is belangrijk: pre-incrementatie vs. post-incrementatie

De operatoren ++ en -- werken anders, afhankelijk van of ze vóór of na de variabele staan:

• Post-increment (value++): Gebruikt eerst de huidige waarde en verhoogt deze daarna met één
• Pre-increment (++value): Verhoogt eerst en gebruikt daarna de nieuwe waarde

int a = 5;
Console.WriteLine(a++);   // Output: 5 (uses old value, then increments)
Console.WriteLine(a);     // Output: 6 (a was incremented)

int b = 5;
Console.WriteLine(++b);   // Output: 6 (increments first, then uses new value)
Console.WriteLine(b);     // Output: 6

Dezelfde regels zijn van toepassing op -- (verlagen).

Delen met gehele getallen versus decimalen

Wanneer u twee gehele getallen deelt, wordt in C# het decimale gedeelte afgekapt:

int result = 7 / 2;
Console.WriteLine(result);     // Output: 3 (not 3.5)

Als u decimaal wilt houden, moet ten minste één van de getallen een decimaal type zijn:

decimal result = 7m / 2m;
Console.WriteLine(result);     // Output: 3.5

Daarom is het kiezen van het juiste gegevenstype belangrijk voor uw berekeningen. In de volgende sectie leert u hoe u kunt converteren tussen typen wanneer dat nodig is.