6. Programstyrning
Ett villkor i C++ är ett uttryck som kan tolkas som sant eller falskt. Dessa representeras av numeriska värden. Är värdet noll, så är uttrycket falsk, allt annat är sant. Det uttryck som skall tolkas kan vara en jämförelse mellan värden (till exempel a = = b), det kan också vara ett fast värde (till exempel 1), en variabel, ett funktionsanrop, eller resultatet av en beräkning. Exempelvis skulle uttrycket 1 - 1 tolkas som falskt i ett villkor, eftersom resultatet av denna beräkning är noll. Observera här alltså att även ett uttryck som en likhetskontroll, till exempel a = = b, har ett värde. Sant (skilt från noll) om a är lika med b, falskt (noll) om a inte är lika med b. Vi ska strax se hur villkor används i upprepningar och val för att styra programmets logik.
|
Definition: Ett villkor är ett uttryck som har ett värde. Är uttryckets värde noll är villkoret inte uppfyllt, det är falsk. Alla andra värden uppfyller villkoret, det vill säga är sanna. |
Ett villkor kan vara till exempel:
Ett sammansatt villkor är flera villkor som satts samman. Man kan till exempel ha en situation när två olika villkor ska vara uppfyllda. Då säger man att det ena villkoret och det andra villkoret ska vara uppfyllt. En annan situation kan vara att antingen det ena eller det andra ska vara uppfyllt, eller båda. Då använder man eller. 'Och' skrivs som '&&' medan 'eller' skrivs som '||'. Nedanstående två villkor avser respektive utesluter ett intervall av talvärden:
iTal > 3 && iTal < 7 // Avser talen 4 till 6.
iTal < 4 || iTal > 6 // Utesluter talen 4 till 6.
Man kan naturligtvis fortsätta att kombinera ihop villkor. Låt oss för enkelhets skull arbeta en stund med villkor som vi helt enkelt kallar 'A', 'B' och så vidare. De två ovanstående villkoren skulle i så fall kunna uttryckas A && B respektive C || D, om nu A står för iTal > 3 etcetera. Vad skulle då följande villkor innebära:
A && B || C
Antingen kan man tolka det så att det räcker med att A och B är uppfyllda eller att C är uppfyllt. Men man kan även se det så att A måste vara uppfyllt medan bara en av B eller C behöver vara uppfyllda. Det går inte att avgöra detta genom att betrakta uttrycket. Man skulle dock kunna använda parenteser. Våra två tolkningar blir i så fall:
(A && B) || C
A && (B || C)
Nu har vi två entydiga sammansatta villkor. Detta problem uppstår bara om man blandar 'och' med 'eller'.
Man kan vända betydelsen av ett villkor genom att använda icke-operatorn, !. Om vi i det andra uttrycket ovan vill säga att A måste vara falskt medan B ska vara sant eller C ska vara falsk, kan man skriva det så här:
!A && (B || !C)
Vill man sedan helt vända betydelsen av detta så bygger man bara på uttrycket:
!(!A && (B || !C))
Nu börjar det bli lite väl svårläst, speciellt med tanke på att vi inte har talat om vad A, B och C står för, vilket kan vara vad som helst från listan ovan, inklusive sammansatt villkor.
I första stycket i detta avsnitt visades exempel på en jämförande operation, nämligen a = = b. Detta betyder att a ska jämföras med b. Om a är lika med b är uttrycket sant, annars är det falskt. Observera att variablerna a och b måste vara av kompatibla typer, det vill säga typer som passar ihop. Vanligen är de av samma typ. Man kan naturligtvis lika gärna jämföra en variabel med en konstant, till exempel a = = 5. Det ska vara två likhetstecken för att det ska bli en jämförelse. Använder man ett likhetstecken blir det en tilldelning, vilket i sig är ett uttryck och har ett värde, och därför kan användas som villkor. Oavsett vilket värde som finns i a resulterar 'a = 0' i att a blir noll och att villkoret är falskt.
Därefter har vi sett exempel på jämförelseoperatorerna för är större än '>' respektive är mindre än '<'. Förutom dessa finns även är större än eller lika med '>=', är mindre än eller lika med '<=' samt är inte lika med '!='. Observera att dessa operatorer betraktas som reserverade ord det vill säga nyckelord i C++. Det innebär att man inte kan skriva '=>' i stället för '>=', '=<' i stället för '<=' eller '=!' i stället för '!='.
Om man utför operationerna '++' eller '--' på en variabel gör det skillnad huruvida operatorerna står före eller efter variabelnamnet. Uttrycket 'iTal++' betyder att villkoret är det värde iTal har före ökning med 1. Därefter ökas iTal med 1. Om man i stället skriver '++iTal' kommer värdet i iTal först att ökas med ett. Därefter avgörs villkorets värde.
Övningsuppgift 6.1.1:
Nu ska vi se hur man kan använda villkor för programstyrning. Vi ska först ta och titta på val, eller för att använda terminologin från JSP, selektion. Val används när man behöver utföra ett kodavsnitt bara om ett eller flera villkor är uppfyllda. I C++ finns två instruktioner för detta, nämligen if och switch. Dessa skall vi studera närmare nedan.
Först ska vi dock ta och förklara hur de syntaxdiagram vi skriver framöver skall tolkas. För att skriva ett fullständigt syntaxdiagram behöver vi ibland ange saker som man får ta med i de fall de behövs, men som också kan utelämnas. Detta markeras genom att innesluta den valfria delen av uttrycket inom hakparenteser, ‘[ ]’. Till exempel:
cout << "Text som ska skrivas ut."[ << variabel];
Om fler saker får vara med, det vill säga att [ ] får upprepas valfritt antal gånger, anges detta med tre punkter, ‘[ ]...’. Till exempel:
a = b[ = c]...;
Om satsen kan innehålla en av flera olika typer kan man ange antingen eller, ‘|’.
Exempel:
cout << "Text"|variabel|värde[ << "Text"|variabel|värde]...;
Nu går vi över till att använda våra villkor. Vi börjar med if och else.
Ibland har man en situation där man vill utföra en eller flera programsatser endast om ett visst villkor är uppfyllt. Man kan då använda if för att avgöra om programsatsen/satserna ska utföras. Syntaxen är som följer:
if(villkor)
{
programsats;
...
}
Observera att syntaxen säger att villkoret ska stå mellan parenteser. Beslutet avser ett efterföljande kodavsnitt, vilket syntaxen ovan beskriver. Om beslutet däremot bara gäller en programsats kan man utesluta klamrarna, och då blir syntaxen så här i stället:
if(villkor) programsats;
...eller:
if(villkor)
programsats;
Övningsuppgift 6.2.1:
Nu har vi fått en funktionalitet som går ut på att en eller flera programsatser styrs av ett villkor. Redan när man tittar på ovanstående exempel anar man ett behov att göra något om villkoret inte är uppfyllt, utan att man för den skull tar bort det som ska ske om villkoret är uppfyllt. Om villkor är uppfyllt ska en sak ske annars ska en annan sak ske. Annars heter else på engelska, och det blir nästa nyckelord. Man får använda else efter den kod som styrs av en if-sats:
if (villkor)
{
programsats; // Satser som körs om <villkor> är sant
...
}
else
{
programsats; // Satser som körs om <villkor> är falskt
...
}
...eller:
if (villkor)
programsats; // Endast en sats
else
programsats; // Endast en sats
...eller:
if (villkor) programsats; // Endast en sats
else programsats; // Endast en sats
Man kan naturligtvis ha flera satser efter if och en efter else och vice versa. Det är dock mindre tydligt hur programmet fungerar om man till exempel skriver:
if (villkor) programsats; // Endast en sats
else
{
programsats; // Satser som körs om <villkor> ej är sant
...
}
Risken är att man inte ser ordet 'else' i ovanstående skrivsätt, och därför missuppfattar programmets funktion.
Övningsuppgift 6.2.2:
Om man nu kan styra exekvering av en programsats, det vill säga huruvida en programsats ska utföras, genom att använda if och else, och detta kan stå på en plats där man normalt skriver en programsats, då går det kanske att placera if-satser inuti de kodavsnitt som styrs av if och else. Helt riktigt kan man göra det. Detta kallas för att nästla if-satser. Nästla är en försvenskning av engelskans 'nestle', vilket betyder inbädda, man bäddar in if-satser i varandra.
Vanligt är att man bäddar in if-satser i else-delen:
if (villkor1)
programsats1;
else if (villkor2) // else avser första if
programsats2;
else if (villkor3) // else avser andra if
programsats3;
[else // else avser tredje if
programsats4;]
Denna konstruktion ska tolkas enligt följande:
Ovanstående skapar ett flervägsval. Detta fungerar naturligtvis även med den syntax som medger flera satser i varje kodavsnitt. Tidigare hade vi ett tvåvägsval i vår övningsuppgift. Vi ska strax titta på ett annat sätt att skapa flervägsval.
Övningsuppgift 6.2.3:
?
if, else.Övningsuppgift 6.2.4:
int iTal = 2;
if(iTal < 15)
{
cout << "iTal = " << iTal << '\n';
}
Övningsuppgift 6.2.5:
int iTal = -65;
if(iTal > 64)
{
cout << "iTal = " << iTal << '\n';
}
Övningsuppgift 6.2.6:
int iTal1 = 5;
int iTal2 = 10;
if( (iTal1 <= 10) || (iTal2 > 10) )
{
cout << "iTal1 = " << iTal1 << ", iTal2 = " << iTal2 << '\n';
}
Övningsuppgift 6.2.7:
int iTal;
if(iTal = 4)
{
cout << "iTal = " << iTal << '\n';
}
Övningsuppgift 6.2.8:
int iTal = 2;
if( )
{
cout << "iTal = " << iTal << '\n';
}
Övningsuppgift 6.2.9:
int iTal = -456;
if( )
{
cout << "iTal = " << iTal << '\n';
}
Övningsuppgift 6.2.10:
int x = 2;
int y = 18;
if( )
{
cout << "x = " << x << '\n';
}
Övningsuppgift 6.2.11:
int iTal;
cout << "Var god ange ett tal: ";
cin >> iTal;
if( )
{
cout << "iTal = " << iTal << '\n';
}
Övningsuppgift 6.2.12:
int iTal;
cout << "Var god ange ett tal: ";
cin >> iTal;
if( )
{
cout << "iTal = " << iTal << '\n';
}
Det finns ett annat sätt att hantera flervägsval, vilket ofta passar bättre än nästlade if-satser. Man kan använda en så kallad switch. I en switch kan man använda en variabel för att styra bearbetningen till olika delar av koden. Man anger var bearbetningen ska fortsätta genom att skriva en så kallade case-sats, vilken anger det värde som variabeln måste innehålla för att bearbetningen måste fortsätta just där case-satsen står. Man kan ha många case-satser motsvarande olika värden i variabeln.
Observera att detta endast fungerar som ett hopp framåt. Man måste därför komma ihåg att avsluta varje del av programsatsen med break, annars fortsätter programmet att utföra alla efterföljande case-satser.
Ibland är dock just det som önskas, men det ska vi inte titta på här, eftersom det strider mot den struktur som förordas i JSP. Man kan utrycka saken så, att en switch till naturen strider mot JSP-reglerna. Även den så kallade break-satsen, som vi ska titta mer på senare, strider mot JSP-reglerna. Dessa regelbrott upphäver faktiskt varandra om man tillämpar nedanstående syntax:
switch(variabel)
{
case värde1:
[case värde2:]...
programrader; // Satser som körs om variabel har
break; // värdet värde1 eller ev. värde2
[case värde3:
programrader; // Satser som körs om variabel har
break;]... // värdet värde3
[default:
programrader;] // Satser som körs om variabel har
} // något värde som ej behandlats
Exempel: vi har läst in sifferbetyg 1-5 och skriver ut omdöme:
switch(betyg)
{
case 1:
cout << "Icke godkänd";
break;
case 2:
cout << "Med tvekan godkänd";
break;
case 3:
cout << "Godkänd";
break;
case 4:
cout << "Väl godkänd";
break;
case 5:
cout << "Med utmärkt beröm godkänd";
break;
default:
cout << "Felaktig betygsättning!";
}
Observera att vi förlorat möjligheten att skriva villkor. Endast fasta värden styr bearbetningen. Detta resulterar samtidigt i en effektivare maskinkod. Vi kan dock få tillbaka en funktion, nämligen 'eller'. Skriver man flera case-satser i rad innan man börjar skriva programkoden kommer detta att resultera i att programkoden utförs om ett av angivna värden stämmer överens med det värde som finns i den variabel som angivits i switch-satsen.
Vi kan testa detta genom att modifiera betygssättningen ovan. Låt oss säga att vår femsiffriga betygskala ska översättas till en textbaserad betygsskala med endast fyra olika betyg. Vi kan tänka oss att man inte längre kan få "Med utmärkt beröm godkänd", så att såväl betyget 4 som 5 ska motsvara "Väl godkänd". En 1:a motsvarar att man inte deltagit, och en 2:a att man deltagit, men underkänts. Då skulle exemplet kunna ändras så här:
switch(betyg)
{
case 1:
cout << "Icke deltagit";
break;
case 2:
cout << "Deltagit";
break;
case 3:
cout << "Godkänd";
break;
case 4:
case 5:
cout << "Väl godkänd";
break;
default:
cout << "Felaktig betygsättning!";
}
Övningsuppgift 6.3.1:
Övningsuppgift 6.3.2:
?
switch case.4. Upprepningar.
Ganska snart i programutvecklingen uppstår behovet av att kunna upprepa ett kodavsnitt ett antal gånger. En upprepning, också benämnd slinga eller loop, består i en eller flera programsatser som skall upprepas tills ett villkor ej längre är uppfyllt. Ett exempel på detta kan vara en inmatning av värden från tangentbordet, där man vill att inmatningen skall upprepas ända tills användaren matar in värdet 0. Vi tar ett JSP-exempel:
Detta skulle i C++ kod se ut som följer (Du behöver inte förstå all kod ännu):
int iTal;
do
{
cin >> iTal;
... // Använd värdet till något.
}while(iTal != 0);
Jämför med ovanstående uttryckt i pseudokod:
deklarera heltalsvariabeln iTal
upprepa
{
mata in ett värde i iTal
använd värdet i iTal
}så länge värdet i iTal inte är noll
Ovanstående är ett exempel på en do...while - slinga. Programsatserna i slingans kodavsnitt exekveras först en gång, därefter utvärderas villkoret 'iTal != 0'. Om villkoret är uppfyllt, det vill säga iTal ej är lika med noll, utförs programsatserna i slingans kodavsnitt en gång till, varefter villkoret utvärderas igen etcetera, ända tills villkoret inte längre är uppfyllt.
I detta fall körs alltid slingans kropp en gång innan villkoret kontrolleras. Detta kan vara önskvärt om man till exempel ämnar skriva ett program som skall avslutas av att användaren matar in ett särskilt värde. Då behöver man alltid minst en inmatning. Vi ska titta mer på do-while-slingan efter att vi bekantat oss med while-slingan i nästa avsnitt.
Övningsuppgift 6.4.1:
I andra situationer kan det vara önskvärt med en kontroll av villkoret innan slingan påbörjas, man kanske inte alls behöver köra koden i slingan. För detta ändamål finns while - slingan. Slutligen finns for - slingan, som är ett kompaktare sätt skriva en while - slinga. Läs mer om dessa i följande avsnitt.
While betyder "medan", eller "så länge som" och används för att upprepade gånger utföra en eller flera programsatser. I parentesen efter while står ett villkor, och så länge detta är uppfyllt utförs den eller de programsatser som följer mellan klamrar. Om villkoret inte är uppfyllt från början utförs inte dessa programsatser alls. För att upprepningen ska kunna avbrytas måste det ske något inom programsatserna som förändrar villkoret så att det slutligen inte längre är uppfyllt. Dock kan ju en variabel automatiskt räknas upp (eller ner) i samband med användning, och den kan ju användas i villkoret. Se exemplet med ASCII-listan i nästa avsnitt.
Syntax:
while(villkor)
{
[programsats]...
}
Vi har här ett par exempel. Det första har ett villkor som är beroende av värdet i en heltalsvariabel iTal, vilken initierats så att villkoret är uppfyllt när programmet kommer till while-slingan. Värdet i iTal ökas sedan i kodavsnittet, varvid programslingan så småningom kommer att avbrytas genom att villkoret inte längre är uppfyllt:
int iTal = 0;
while(iTal < 25)
{
cout << "Nu är iTal = " << iTal << ´\n´; // Skriv ut iTal
iTal++; // Räkna upp iTal
}
Man kan även använda uppräkningsoperatorn i villkoret. Om man skriver 'iTal++' kommer villkoret att utvärderas innan iTal ökar värde med ett:
int iTal = 0;
while(iTal++ < 25) // iTal räknas upp efter testet
{
cout << "Nu är iTal = " << iTal << ´\n´;
}
Om man av någon anledning vill skriva en slinga som aldrig avbryts kan man skriva vad som hels som alltid är sant. Man kan till exempel skriva så här:
while(1) // En etta som villkorl gör en evig slinga!
?
While.Övningsuppgift 6.5.1:
int i = 2;
while(i < 15)
{
i = i + 6;
}
Övningsuppgift 6.5.2:
int iTal = ;
while( )
{
}
Övningsuppgift 6.5.3:
Övningsuppgift 6.5.4:
Övningsuppgift 6.5.5:
Övningsuppgift 6.5.6:
I motsats till while, utförs kroppen i en do...while slinga alltid minst en gång. Med hjälp av do...while flyttar vi testen tills efter programsatserna, och därigenom kommer alltid programsatserna att utföras minst en gång. I övrigt fungerar den på samma sätt som while.
Syntax:
do
{
[<programsats>;]...
} while (<villkor>);
Exempel: Skriv ut 16 tecken och deras respektive ASCII-värde.
#include <iostream.h>
void main()
{
int iStart = 1;
char cStart = 1;
int iSlut = 0;
do
{
//Första gången är iStart = 1 och iSlut = 0, alltså
//blir vilkoret falskt!
while (iStart <= iSlut)
{
//Observera här att cout kontrollerar datatypen hos den
//variabel som skrivs ut. En char skrivs ut som tecken,
//medan en int med samma värde skrivs ut som tal!
cout << "ASCII-koden för " << cStart << " = "<< iStart;
cout << "\n";
iStart++; //Räkna upp både char och int variablerna.
cStart++;
}
cout << "\n" << "Var vill du börja lista\?";
cin >> iStart;
cStart = iStart;
cout << "\n";
iSlut = iStart + 16;
}while (iStart > 0);
}
?
Do.
Övningsuppgift 6.6.1:
int i = 0;
do
{
i = i + 2;
} while(i < 20);
Övningsuppgift 6.6.2:
int iTal = ;
do
{
} while( );
Övningsuppgift 6.6.3:
7. for.
I en while-slinga initierar man en variabel i förväg, testar den före utförandet av slingans programsatser samt gör omräkning för vidare test antingen vid test eller bland programsatserna. Do...while-slingan gör i stort sett samma sak, men testar efter programsatserna.
For, däremot, samlar allt detta på ett och samma ställe: inom parenteserna efter nyckelordet "for", åtskilda med semikolon.
Syntax:
for (<variabelinitiering>; <villkor>; <uppräkning>)
{
[<programsats>;]...
}
Först initieras variabelns värde, sedan kontrolleras villkoret, därefter körs programsatsen eller programsatserna i slingans kropp. Sedan görs uppräkningen enligt uppräkningsvillkoret.
Vill man göra en loop som utför någonting 100 gånger 100 kan man skriva så här:
for (iTal = 0; iTal < 100; iTal++)
{
...
}
Använder man iTal i kodavsnittet måste man tänka på att iTal första gången har värdet 0, andra gången värdet 1 och så vidare, för att sista gången ha värdet 99, inte 100. Detta passar utmärkt till listor, där första elementet är noll. Är listan deklarerad med 100 element är sista elementet element nummer 99.
Man kan initiera flera variabler på en gång, och även räkna upp flera på en gång. Man kan t.o.m. utföra hela beräkningar i uppräkningsdelen. Villkoret kan naturligtvis vara sammansatt, d.v.s. bestå av flera villkor sammansatta med && eller ||.
?
for.
Övningsuppgift 6.7.1:
int i;
int j = 0;
for (i = 0; i <= 100; i++)
{
j = j + 2;
}
Övningsuppgift 6.7.2:
for ( ; ; )
{
}
Övningsuppgift 6.7.3:
Övningsuppgift 6.7.4:
Övningsuppgift 6.7.5:
Övningsuppgift 6.7.6:
Nu har vi tittat på tre olika typer av slingor. Dessa passar mycket bra in i JSP-strukturerat tänkande. Samma gäller 'if'. Slingor motsvarar ju ett block i JSP märkt med en stjärna i övre vänstra hörnet. I valsituationer byter man stjärnan mot en liten cirkel. (Känner du inte igen dig nu, så titta i dina anteckningar från de två introduktionsveckorna.)
Vi kunde även styra programflödet med 'switch', men som vi även såg måste man anpassa denna instruktion till JSP genom att vi introducerade en 'break' efter varje 'case', och därmed låter den ena oegentligheten uppväga den andra.
Instruktionen 'brake' har en like i en annan instruktion, continue. Nu ska vi (tyvärr) titta på hur man kan förstöra denna vackra symmetri med hjälp av dessa två.
Som du säkert märkt är det inte alltid så lätt att strukturera programmet på sådant sätt att man helt följer JSP-strukturen. Man kanske tar ett beslut mitt i en slinga som resulterar i att men kanske vill avbryta den även om slutvillkoret inte uppfyllts, eller bara hoppa över bearbetningen detta varv och hoppa till slingans början igen. Detta kan man göra med break respektive continue.
Dessa båda instruktioner har till funktion att utföra ett programhopp ut ur aktuellt sammanhang, till exempel ett kodavsnitt tillhörande en programslinga eller en if-sats eller en switch. I en switch finner 'break' sin naturliga plats eftersom 'switch' bryter mot JSP. I alla andra fall kan man alltid finna en JSP-anpassad lösning. Så här kan man använda 'break' för att ta bort de tal som förekommer dubbelt i programmet 'Produkt' från övningsuppgiften ovan:
#include <iostream.h>
void main()
{
int rad, kol;
for (rad = 1; rad <= 10; rad++)
{
for (kol = 1; kol <= 10; kol++)
{
if (kol > rad) break;
cout.width(4);
cout << rad * kol;
}
cout << "\n";
}
}
Observera hur 'break' avbryter bearbetningen av en rad så fort kolumnnumret överstiger radnumret. Så här blir utskriften:
Övningsuppgift 6.8.1:
Som vi ser skapar 'break' ett programhopp förbi den slutklammer som markerar innevarande sammanhangs slut.
Instruktionen continue gör däremot ett programhopp till samma slutklammer. Detta får till följd att villkoret testas igen, och om det fortfarande är uppfyllt kommer kodavsnittet att köras igen. Man kan se det som att 'break' helt och hållet hoppar ur en programslinga medan 'continue' hoppar över resten av innevarande 'varv' i programslingan. Tänk på att 'break' kan användas även i andra sammanhang, till exempel med 'switch', medan 'continue' endast används i slingor.
Här följer ett dåligt exempel på hur man kan använda 'continue'. Det är samma program igen, men här tar vi bort alla kvadrater, det vill säga själva diagonalen i utskriften. Villkoret är alltså att vi inte skriver ut de produkter där kolumnnumret är lika med radnumret:
#include <iostream.h>
void main()
{
for (int rad = 1; rad <= 10; rad++)
{
for (int kol = 1; kol <= 10; kol++)
{
if (kol == rad) // Är vi på diagonalen?
{
cout << " "; // Skriv ut blanka i stället.
continue; // Hoppa över resten av detta varv.
}
cout.width(4);
cout << rad * kol;
}
cout << "\n";
}
}
Så här blir det när man kör programmet.
Övningsuppgift 6.8.2:
?
Break, continue.9. goto.
Rubricerat ord som är att betrakta som en svordom i C++! Själva språkets uppbyggnad gör att man gärna skriver välstrukturerade program a’la JSP, och gör man ett s.k. "vilt programhopp" här, så har man med största sannolikhet gjort ett stort avsteg från sin vackra struktur. Jag har t.o.m. hört talas om programmeringsföretag som mer eller mindre förbjudit användandet av goto. På ADB Malmö fick vi endast använda goto för att avbryta en slinga eller ett kodavsnitt genom att hoppa fram till slutet, men i C++ kan man lika gärna placera resten av koden i ett else-avsnitt.
Det finns dock en situation då det är nästan rumsrent att använda goto: Man har nästlat sig djupt in i ett antal slingor och upptäcker av någon anledning ett fel, och en snygg exit är onödig eftersom programmet ändå måste avbrytas. Då behöver man inte lämna varje slinga för sig med ett break, utan kan hoppa ut till yttersta slingans slut med ett goto. Men de flesta arbetsgivare skulle inte ens godkänna detta, eftersom det finns verktyg för felhantering som lätt hanterar även denna situation, och dessutom upplyser användaren om vad som har gått fel.
Vi ska ändå kunna förstå en kod som innehåller goto, och därför ska vi se hur man använder instruktionen. För att kunna hoppa med goto behöver man en programetikett att hoppa till. En programetikett är ett (nästan) fritt valt ord vilket avslutats med kolon.
Syntax:
goto <etikett>;
...
<etikett>:
Exempel:
goto Avbryt;
...
Avbryt:
?
Goto.