Het programma logica geven

Nu we weten hoe het mogelijk is om de gebruiker invoer op te laten geven, deze simpel te verwerken en vervolgens weer terug aan de gebruiker te geven, is het ook belangrijk om te kunnen beslissen. Zoals; is de invoer wel geloofwaardig (afhankelijk van wat je zelf geloofwaardig vindt!); of andere eisen die moeten worden gesteld.

Keuzes maken met if structuur

Een programma kan als het ware keuzes maken met een if lus. Dit zijn zeer simpele keuzes als ja/nee. Hier bij komt een boolean weer na voren; aangezien die waar/niet waar kan bevatten (een andere vorm van ja/nee). We kunnen bijvoorbeeld een keus maken om de gebruiker een melding te geven als die aangeeft dat er wel 1000 appels in een kist zitten:

CSHARP Code
1
2
3
4
5
6
7
8
9
 
// ... (de rest van het programma, zie vorige pagina).
// Het aantal is net ingelezen (zie vorige pagina) enz.
AppelsPerKist = Convert.ToInt32( Invoer );
 
if (AppelsPerKist >= 1000)
{
      Console.Writeline("Dat zijn wel heel veel appels per kist!");
}


Hier zijn 2 dingen van belang:
CSHARP Code
1
2
3
4
if ([Voorwaarde])
{
      [Instructies]
}


Er is in dit geval maar een voorwaarde; AppelsPerKist >= 1000. Als wat tussen de haakjes van if waar is (true), dan worden de instructies tussen de Accolades uitgevoerd. Wanneer de voorwaarde niet waar is (false), dan wordt die niet uitgevoerd.

Hier bij wordt een vergelijking met de variabele AppelsPerKist gedaan. De operator >= betekent ‘groter of gelijk aan’ wat daarachter staat (1000). Indien dus AppelsPerKist groter of gelijk is aan 1000, is die voorwaarde ‘waar’. Dan wordt in het voorbeeld dus een regel geprint met een melding dat het aantal appels per kist wel erg groot is.

Er zijn verschillende vergelijkingen (voorwaarde) in dit geval van belang:
  • A == B A is gelijk aan B: Niet te verwarren met wordt gelijk aan , die we voorheen hebben gebruikt met het een waarde toekennen van een variabele. Als we kiezen dat AppelsPerKist == 50; dan moet AppelsPerKist echt 50 zijn om die voorwaarde tot waar te maken.
  • A != B A is niet gelijk aan B: Het tegenovergestelde wat hierboven staat. Als A en B gelijk zijn, is deze voorwaarde niet waar.
  • A > B A groter dan B: Om deze voorwaarde waar te maken, moet A groter zijn dan B, of B kleiner zijn dan A.
  • A < B A kleiner dan B: Om deze voorwaarde waar te maken, moet A kleiner zijn dan B, of B groter zijn dan A (net hoe je het bekijkt). A en B kunnen variabelen of vaste getallen zijn!
  • A >= B A groter dan, of gelijk aan, B: Net zoals bij A groter dan B, maar nu mag A ook gelijk zijn aan B. Bij die andere moet A perse groter zijn!
  • A <= B A kleiner dan, of gelijk aan, B. Net zoals bij A kleiner dan B, mag A nu ook gelijk zijn aan B.

De vergelijkingen A == B en A != B zijn altijd toepasbaar. De anderen zijn enkel toepasbaar op integers, floats en doubles.

Maar stel dat we de volgende lussen nemen:
CSHARP Code
1
2
3
4
5
6
7
8
if (true)
{
    Console.WriteLine("Lus 1");
}
if (false)
{
    Console.WriteLine("Lus 2");
}


De uitkomst van dit programma is ‘Lus 1’. Dat komt omdat true altijd waar is. False is altijd niet waar. Je moet het zien dat de vergelijkingen die voorheen in het lijstje gegeven zijn, eerst terug te vertalen zijn naar ‘true’ of ‘false’. Een andere verdieping daar in:
CSHARP Code
1
2
3
4
5
6
7
int Getal = 1000;
bool DeVoorwaarde = Getal > 500;
 
if (DeVoorwaarde)
{
    Console.Writeline("Getal is groter dan 500");
}


Is het zelfde als:
CSHARP Code
1
2
3
4
5
int Getal = 1000;
if (Getal > 500)
{
    Console.WriteLine("Getal is groter dan 500");
}


Tevens is het ook mogelijk (en vaak nodig) om verschillende vergelijkingen tot 1 resultaat te geven. Bijvoorbeeld; je wilt een bericht weergeven als Getal tussen 500 en 1500 ligt. Dat wilt dus zeggen dat Getal > 500 waar moet zijn, maar ook Getal < 1500 waar moet zijn. We moeten hier een AND vergelijking op toepassen. Dat is in C# te schrijven als &&:

CSHARP Code
1
2
3
4
5
6
7
8
9
int Getal = 1000;
bool Voorwaarde1 = Getal > 500;
bool Voorwaarde2 = Getal < 1500;
bool DeVoorwaarde = Voorwaarde1 && Voorwaarde2;
 
if (DeVoorwaarde)
{
    Console.WriteLine("De waarde van Getal ligt tussen 500 en 1500 in");
}


In dit geval moeten zowel Voorwaarde1 en Voorwaarde 2 waar zijn. Naast de AND vergelijking bestaat ook nog de OR vergelijking, en XOR:
  • A && B: A AND B. Hier moeten A en B waar zijn.
  • A || B: A OR B. Hier moet A of B waar zijn. Welke maakt niet uit
  • A XOR B; Exclusive OR. Helaas geen standaard operator in C#; maar Exclusive OR wilt zeggen dat de keuze of A of B waar mag zijn, maar beide mogelijk niet gelijk aan elkaar zijn. Dat wilt dus zeggen dat A en B niet tegelijk waar mogen zijn. Wordt slechts zelden gebruikt


If-else structuur

In een programma komt het vaak voor dat een stuk code enkel mag worden worden uitgevoerd als iets waar is. Vaak is er ook nog een handeling te doen als het niet waar is. Met andere woorden; als een voorwaarde waar is, wordt bijvoorbeeld de berekening uitgevoerd. Als het niet waar is, dan wordt een melding naar de gebruiker gegeven. Voorbeeld:
CSHARP Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
// .... 
// Een willekeurige invoer inlezen, van Invoer..
int Appels = Convert.ToInt(Invoer);
 
// Als getal groter is dan 500, en kleiner is dan 1500, dan:
if (Appels > 500 && Appels < 1500)
{
    double Gewicht = Appels * 0.1;
    Console.Write( "Het gewicht van de appels is: " );
    Console.Write( Gewicht );
    Console.WriteLine( "kg" );
}
else
{
    Console.WriteLine("Het aantal appels moet tussen de 500 en 1500 liggen!");
}


Hier bij is de volgende structuur te zien:
CSHARP Code
1
2
3
4
5
6
7
8
9
 
if ([Voorwaarde])
{
    [Instructies als de voorwaarde TRUE is]
}
else
{
    [Instructies als de voorwaarde FALSE is]
}


Een ‘variant’ op deze structuur heet de if-elseif-else structuur. Hier bij is het mogelijk om een tweede, derde, enz. voorwaarde een kans te geven. Bijvoorbeeld:
CSHARP Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
if ([Voorwaarde 1])
{
    [Instructies als de voorwaarde 1 TRUE is]
}
else if ([Voorwaarde 2])
{
    [Instructies als de voorwaarde 2 TRUE (1 dus niet, 3 zijn we nog niet geweest) is]
}
else if ([Voorwaarde 3])
{
    [Instructies als de voorwaarde 3 TRUE (1&2 dus niet!) is]
}
else
{
    [Instructies als geen enkele voorwaarde TRUE is]
}


Switch structuur

Wat ook wel eens wilt voorkomen is dat er talloze if-else cases komen. Een variabele (Bijvoorbeeld OptieKeuze) heeft een paar mogelijke waarden. Voorbeeld:
CSHARP Code
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int Keuze = [..]; // lees een keuze in.
switch (Keuze)
{
    case 1:
        Console.WriteLine("Keuze 1");
        break;
    case 2:
        Console.WriteLine("Keuze 2");
        break;
    case 3:
    case 4:
        Console.WriteLine("Keuze 3 OF 4");
        break;
    default:
        Console.WriteLine("Keuze was ongelijk aan alle andere mogelijke caaes");
        break;
}


Als keuze gelijk is aan 1, in de console Keuze 1 geprint. Vervolgens wordt doormiddel van het break statement uit de switch lus gesprongen. Bij de waarde 2 hetzelfde verhaal. Bij 3 en 4 ligt het wat anders; als Keuze gelijk is aan 3 of 4 aan, zal die Keuze 3 OF 4 printen, en vervolgens de switch lus uit springen. Dit is een simpele manier om aan meerdere waarde van Keuze dezelfde code uit te laten voeren.

Default wordt gepakt als geen van de andere cases voldoen.