Noter til C# Programmering
Programmer
udfører det meste af deres arbejde vha. forgrening og løkker.
Mange
programmeringsproblemer kan løses ved at gentage en handling på de samme data
At
iterere vil sige at udføre den samme
handling igen og igen. I C# findes grundlæggende tre løkke-strukturer, som vi
skal se nærmere på. Hver især besidder de forskellige egenskaber, der
kvalificerer dem til forskellige problemstillinger. Mulighederne for at
modificere og skræddersy de tre løkker er imidlertid så omfattende, at alle tre
løkkestrukturer kan bringes til at ligne hinanden.
En
while-løkke får programmet til at udføre en kodeblok, sålænge startbetingelsen
er sand. I det følgende eksempel bliver løkkeinstruktionen udført (tælleren
blev opskrevet) indtil tælleren er lig med 5.
Eksempel
int tæller = 0; // Initialisér tælleren
while(tæller < 5) // Test om betingelsen er sand
{
tæller
= tæller + 1;
Console.WriteLine("Tælleren er " + tæller);
}
Console.WriteLine("Løkken er færdig – tælleren er nu " + tæller);
Console.ReadLine();
Nogle
gange ønsker man at returnere til toppen af løkken uden at hele kodeblokken
bliver afviklet. Dette kan gøres med continue, idet continue-sætningen
springer tilbage til toppen af løkken.
Eksempel
int tæller = 0; // Initialisér tælleren
while(tæller < 10) // Test om betingelsen er sand
{
tæller
= tæller + 1;
if (tæller % 2 != 0)
continue;
Console.WriteLine("Tælleren er " + tæller);
}
Console.WriteLine("Løkken er færdig – tælleren er nu " + tæller);
Console.ReadLine();
Programmet udskriver de lige tal mellem
1 og 10. Hvorfor? Prøv at lave et program med en while-løkke, der
udskriver de lige tal mellem 1 og 10 uden brug af continue. Prøv med en
for-løkke, se
senere…
Betingelsen, som evalueres i en while-løkke, skal
være et boolsk udtryk. En while-løkke vil udføres, sålænge
udtrykket er sandt. Det efterfølgende eksempel viser en ”uendelig løkke”, der
dog termineres vha. nøgleordet break. Brugen af break er den
eneste mulighed for at undslippe denne løkke.
Eksempel
int tæller = 0; // Initialisér tælleren
while(true) //
Betingelsen er altid sand
{
tæller
= tæller + 1;
Console.WriteLine("Tælleren er " + tæller);
if (tæller >= 5)
break;
}
Console.WriteLine("Løkken er færdig – tælleren er nu " + tæller);
Console.ReadLine();
Ovenstående eksempel svarer til de to
første eksempler i denne note.
I
en almindelig while-løkke kan det ske, at den indeholdte kodeblok aldrig bliver
genneløbet, fordi startbetingelsen er falsk allerede inden det første
gennemløb. Til at overkomme dette problem kan man gøre brug af strukturen do…while. De to
nedenstående eksempler viser hhv. effekten af while og do…while
Eksempel
(Prøv at indtaste forskellige tal)
int tæller;
Console.Write("Hvor mange prikker? ");
tæller
= int.Parse(Console.ReadLine());
while(tæller > 0) // Test betingelsen
{
Console.Write(".");
tæller
= tæller - 1;
}
Console.WriteLine("Løkken er færdig – tælleren er nu " + tæller);
Console.ReadLine();
Eksempel (Prøv at indtaste forskellige
tal)
int tæller;
Console.Write("Hvor mange prikker? ");
tæller = int.Parse(Console.ReadLine());
do
{
Console.Write(".");
tæller
= tæller - 1;
} while(tæller > 0); // Test betingelsen
Console.WriteLine("Løkken er færdig – tælleren er nu " +
tæller);
Console.ReadLine();
Læg mærke til, at uanset hvilken værdi,
der indtastes i det sidste eksempel, så gennemløbes løkken mindst én gang. continue og break virker begge
i do…while-løkken
præcis som de virker i while-løkken. Den eneste forskel
mellem de to løkke-typer er tidspunktet for test af betingelse.
Et typisk eksempel på brugen af do…while er følgende,
hvor man udfører en programstump, indtil brugeren takker nej på spørgsmålet om,
hvorvidt han ønsker at fortsætte.
Eksempel:
int resultat;
double tal;
do {
Console.Write("Indtast et
tal: ");
tal = double.Parse(Console.ReadLine());
Console.WriteLine("Kvadratroden af " + tal + " er " + Math.Sqrt(tal));
Console.Write("Tast 1, hvis du vil prøve igen: ");
resultat = int.Parse(Console.ReadLine());
} while(resultat!= 1); // Test betingelsen
I
en while-løkke
opstilles en startbetingelse, der testes hvorvidt denne er sand, og endelig
opskrives eller på anden vis ændres en tællevariabel for hvert løkkegennemløb.
Lad os betragte endnu et eksempel på en while-løkke.
Eksempel
int tæller = 0;
while(tæller < 5)
{
tæller
= tæller + 1;
Console.WriteLine("Itererer...");
}
Console.WriteLine("Løkken er færdig – tælleren er nu " + tæller);
Startbetingelsen sættes i anden linje, tæller initialiseres til 0. I næste
linje testes betingelsen – er tæller
mindre end 5, og endelig i første sætning i while-løkken
opskrives tælleren tæller. Herefter
udskrives et mindre intelligent budskab, men denne blok kunne også indeholde
mere vigtig kode.
En for-løkke
sammenfatter alle tre trin i ét, altså initialisering, test og opskrivning i ét
enkelt hug. Syntaksen er nøgleordet for efterfulgt af en parentes indeholdende
3 sætninger adskilt af semikoloner. Den første sætning er initialiseringen. Den
næste er test af stopbetingelse, og her skal et boolsk udtryk indpasses. Den
tredje sætning er selve handlingen. Denne er typisk en opskrivning eller
nedskrivning af en variabel, men her kan enhver gyldig C#-sætning indpasses.
Bemærk at den anden sætning skal være et boolsk udtryk, dvs. en sætning som
returnerer enten sand eller falsk (true eller false). Lad os
betragte et eksempel.
Eksempel
int tæller;
for (tæller = 0; tæller < 5; tæller++)
{
Console.WriteLine("Itererer...");
}
Console.WriteLine("Løkken er færdig – tælleren er nu " + tæller);
for-løkker er særdeles fleksible og
kraftfulde. De udføres i følgende tre trin:
·
Operationen i initialiseringsdelen udføres
·
Stopbetingelsen evalueres
·
Hvis betingelsen er sand, så udføres handlingen samt
kodeblokken i selve løkken.
Herefter gentages trin 2 og 3.
for-løkker kan som sagt være særdeles
fleksible, hvilket vil fremgå af de næste eksempler
Det
er muligt, at lade for-løkken håndtere mere end én variabel. Betragt følgende
eksempel. Prøv at indtast koden og kør den. Hvad sker der?
Eksempel
for (int i = 0, j = 0; i <
3; i++, j++)
Console.WriteLine("i: " + i + "
j: " + j);
Det
er muligt at udelade en eller flere af for-løkkens sætninger
(Initialisering, test af betingelse og handling).
Eksempel
int tæller = 0, max;
Console.Write("Hvor mange prikker? ");
max = int.Parse(Console.ReadLine());
for (;;) // Uendelig for-løkke
{
if
(tæller < max) // Test
{
Console.Write(".");
tæller = tæller + 1;
}
else
break;
}
Ligesom
det er muligt at udelade en eller flere af for-løkkens
sætninger, er det muligt at undlade at have sætninger i selve løkken.
Eksempel
for (int i = 0; i < 5; i++, Console.Write("."))
;
for-løkker
kan også indlejres, hvilket følgende eksempel illustrerer.
Eksempel
for (int i = 0; i < 5; i++)
{
for (int j = 0 ; j <
10; j++)
Console.Write(".");
Console.WriteLine();
}
Som
eksemplerne i det foregående har vist, så er alle tre løkketyper, while, do…while og for-løkken så
fleksible, at de alle tre vha. continue og break kan formes
til at udføre den samme handling. Hvornår skal man så benytte hvilken? Der
findes ingen forskrifter, men en tommelfingerregel kunne være:
·
Brug for-løkker, når antallet af
iterationer på forhånd er kendt, ellers
·
Brug while-løkker, når startbetingelsen
skal evalueres inden kodeblokken i selve løkken skal afvikles
· Brug do…while-løkker, når kodeblokken i selve løkken skal afvikles én gang før startbetingelsen evalueres.