1 Villkor och styrsatser I de program vi sett tidigare har programkörning inneburit att sats efter sats utförts i den ordning de skrivits i källkoden. Vi har inte kunna ändra programmets uppförande beroende på inmatningar eller beräkningsresultat. Vi kallar en sådan samling satser för en sekvens, eftersom de utförs en efter en. Sekvens: Start: Sats1 > sats 2 > sats 3 > sats 4 Slut. Vi ska nu titta på en ny struktur som kallas för selektion. Selektion innebär att programmet kan under programkörning fatta beslut om vilken av en, två eller flera alternativa sekvenser som ska utföras. 1.1 Villkorssatsen if En villkorssats är den konstruktion som finns i C++ för att göra en selektion av två alternativa sekvenser. Formen för if satsen är alternativt if ( logiskt_uttryck ) sats / satsblock else sats / satsblock if ( logiskt_uttryck ) sats / satsblock Det logiska uttrycket anger ett villkor som är antingen sant eller falskt. Den första sats/satsblocksdelen är det programavsnitt som ska utföras om villkoret är sant. Den andra sats/satsblocksdelen är det som ska utföras om villkoret är falskt. else och det efterföljande sats/satsblock är valfritt. Några enkla exempel: int antal_husdjur; cout << "Ange hur många husdjur du har hemma"<<endl; cin >> antal_husdjur; cout << "Jaså du har "<< antal_husdjur<< " husdjur"<<endl; if ( antal_husdjur > 5 ) cout << "Oj det var många"<<endl; cout << "slut"<< endl; Programavsnittet måste fogas in i en main() funktion för att fungera. Detta program har nu två möjliga vägar att gå:
1. Villkoret är sant. Användaren har matat in en siffra större än 5. Ange hur många husdjur du har hemma 12 Jaså du har 12 husdjur Oj det var många slut 2. Villkoret är falskt. Användaren har matat in en siffra som är 5 eller lägre. Ange hur många husdjur du har hemma 2 Jaså du har 2 husdjur slut Villkorssatsen i exemplet utnyttjar att else delen av if satsen är valfri. Dessutom läggs det en sats och inte ett satsblock efter if satsen. if satsen väljer bara den sats som ligger direkt efter villkoret. Notera indragningen av satsen cout<<"oj det var många"<<endl; Indragningen är densamma som ses efter klammern efter main(). Syftet med indragningen är att då man läser programmet ska man enkelt kunna se vilken eller vilka satser som hör till villkoret. Indraget bör vara ungefär 3 4 mellanslag. 1.1.1 Satsblock För att kunna utföra flera satser styrda av ett villkor konstruerar man ett satsblock. Ett satsblock är helt enkelt en sekvens av satser omgärdade av och klamrar. Funktionen main() har också ett satsblock, klamrarna och som anger början respektive slut på programmet. Ett liknande program med satsblock och else satser
int antal_husdjur; cout << "Ange hur många husdjur du har hemma"<<endl; cin >> antal_husdjur; if ( antal_husdjur > 5 ) cout << "Oj det var många hela "; cout << antal_husdjur << " stycken"; cout << endl; else cout << Jaså du har bara"; cout << antal husdjur << " stycken"; cout << endl; cout<<"slut"<<endl; Observera hur indraget ( kallad indentering ) går över hela satsblocken. Programmet kommer nu att välja endast en av vägarna efter if satsen. Om villkoret är uppfyllt utförs satsblocket direkt efter villkoret, annars utförs satsblocket efter else. 1.1.2 Övning: Sätt in ovanstående exempel i ett komplett program och provkör. Blev resultatet det du förväntade dig? Rätta till indenteringen i föregående program. Ett vanligt fel är att man råkar lägga en ensam sats mellan if satsen och satsblocket. Kompilatorn har svårt att ge en rimlig felbeskrivning för detta fel. Ett annat vanligt fel är att man påbörjar satsblocket innan villkorssatsen eller else. Satsblocket blir då som regel betydelselöst. if ( antal_husdjur > 5 ) // FEL! Satsblocket börjar inte direkt efter villkoret cout << "Oj det var många hela "; cout << antal_husdjur << " stycken"; cout << endl; else cout << Jaså du har bara"; // FEL! Satsblocket börjar inte direkt efter else satsen. cout << antal husdjur << " stycken"; cout << endl; Det händer också att man ibland råkar sätta ett semikolon direkt efter if satsens villkor.
if ( längd < 30.7 ); // FEL! cout << "kort längd"; Detta får till följd att en tom sats direkt efter villkoret styrs av if satsen. Eftersom satsen är tom påverkar den inte programmet på något sätt. cout satsen däremot som var tänkt att påverkas av villkoret utförs oavsett resultatet på villkoret eftersom if satsen tar slut i och med semikolonet. 1.2 Logiska villkor I och med villkorssatsen stöter vi på en ny typ at uttryck, de logiska. De logiska uttrycken följer samma mönster som de tidigare operationerna vi sett med den skillnaden att resultatet av en logisk operation alltid är ett booleskt(logiskt) värde, sant eller falskt. Operatorerna som ger logiska resultat kallas, logiskt nog, logiska operatorer. Logiska binära operatorer == Lika med!= Icke lika med < Mindre än <= Mindre än lika med > Större än >= Större än lika med && Logiskt AND Logiskt OR and Borttaget ur C++: Logiskt AND synonymt med && or Borttaget ur C++: Logiskt OR synonymt med I villkoret i exemplet ovan användes den logiska operatorn > på formen ( int ) > ( int ) : bool Varje logisk operation ger ett resultat av typen bool. Man kan använda sig av variabler deklarerade med typen bool för att lagra logiska värden. Villkoret i exemplet ovan hade kunnat skrivas utförligare som: bool manga_husdjur; manga_husdjur = antal_husdjur > 5; if ( manga_husdjur ) // satsblocken som tidigare med samma betydelse. Variabeln manga_husdjur kan alltså anta värdena true eller false. Om ett logiskt värde av typen bool i något uttryck kan betraktas som ett heltal kommer värdet true att vara värdet 1, och false kommer att vara värdet 0. De flesta logiska operationer är tämligen rättframma. Här följer några exempel på hur uttrycken kan se ut:
Antag att förekommande variabler är deklarerade med en rimlig datatyp ( vikt < 60.0 ) ( antal_hundar== 2 ) ( antal_valar!= 2 ) // motsatsen till ovan ( antal*2 >= 52 ) // räkneoperationen utvärderas först Man kan dessutom kombinera uttryck med de logiska operatorerna && ( OCH ) och (ELLER). Dessa operatorer har formen ( bool ) && ( bool ): bool ( bool ) ( bool ): bool Man använder alltså dessa operatorer på logiska värden eller uttryck ( antal == 2 && vikt < 20.0 ) // Jämförelserna utvärderas först och // därefter utvärderas && // båda jämförelserna måste vara sanna för // att hela uttrycket ska vara sant ( antal == 2 vikt < 20.0 ) // om någon av jämförelserna är sanna // är uttrycket sant Det finns även en unär logisk operator! eller not. Operatorn fungerar så att den vänder ett sant värde falskt, och tvärtom. Exempel (!( 3 > 4 ) ) // är sant ( not( 7 == 12 ) ) // är sant (! (4==4) ) // är falskt Det bör sägas ett varningens ord om likhetsjämförelser av flyttal. Om man har två flyttal är det ofta svårt att kontrollera om de är lika, eftersom jämförelsen kräver att de är exakt lika i varje bit. Då varningar utfärdas får man inte glömma bort att varna för en viss typ av sammansatta jämförelser. Betrakta följande programavsnitt int hur_gammal; cout << "Ange din ålder "<<endl; cin >> hur_gammal; // kolla om tonåring, äldre än 12 och yngre än 20 år if ( 12 < hur_gammal < 20 ) // FEL! cout << "Du är tonåring"<<endl; Villkoret kan till en början se riktigt ut, kompilatorn upptäcker troligtvis inget fel. Faktum är att skrivsättet är väldigt vanligt inom algebra. Om man däremot ser i detalj vad villkoret utvärderar ser man ett problem. Den första operationen som utförs är jämförelsen ( från vänster till höger ) 12 < hur_gammal
resultatet av denna operation är av typen bool och används som vänster operand i nästa < operation. Resultatet av uttrycket är antingen 0 eller 1, nästa jämförelse blir därför 1 < 20 om hur_gammal var större än 12 annars 0 < 20 Båda dessa villkor är sanna och hela uttrycket är i princip värdelöst. För att skriva jämförelsen på ett riktigt sätt måste man dela upp den i två jämförelser, dels 12 < hur_gammal och dels i hur_gammal < 20 kombinerade med && (and). // kolla om tonåring, äldre än 12 och yngre än 20 år if ( 12 < hur_gammal && hur_gammal < 20 ) // RÄTT! cout << "Du är tonåring"<<endl; 1.2.1 Nästlade if satser Ett sats i satsblocket kan innehålla vilken annan typ av sats som helst, även andra if satser. Ett villkor sammansatt med && kan även skrivas om som ett nästlat villkor // kolla om tonåring, äldre än 12 och yngre än 20 år alternativ lösning if ( hur_gammal > 12) // personen är äldre än 12 if ( hur_gammal < 20 ) cout << "Du är tonåring"<<endl; Var uppmärksam på skillnaden mellan denna konstruktion och // kolla om tonåring, äldre än 12 och yngre än 20 år felaktig lösning if ( hur_gammal > 12) // personen är äldre än 12 cout << "Du är äldre än 12"<<endl; if ( hur_gammal < 20 ) // personen är äldre än 20 cout << "Du yngre än 20"<<endl; Se också hur indenteringen ändras för nästlade satser. Observera att kommentarerna inte påverkar if satserna och de satser de styr. Testa gärna de olika varianterna vid en dator.
#include<iostream> using namespace std; int main() double tal1, tal2; Exempel, enkel sortering av två tal // ledtext cout << "Detta program undersöker vilket av två tal som är störst"; cout << endl << "Ange det första talet:"<<endl; cin >> tal1; cout << "Ange det andra talet:"<<endl; cin >> tal2; if ( tal1 > tal2 ) cout << "Det första talet, "<<tal1; cout << " är störst"<<endl; else cout << "Det andra talet, "<< tal2<<" är störst"; return 0; 1.2.2 Övning Komplettera programmet så att det även skriver ut det mindre av talen. Vad händer om talen är lika? 1.3 Iteration Iteration innebär en upprepning, repetition av satser. Vi har nu sett hur en villkorssats kan välja att utföra ett satsblock beroende på om ett villkor är uppfyllt, selektion. För selektion formulerades ett villkor om ett satsblock skulle behandlas eller inte. För iterationen gäller att dess satsblock repeteras till dess att villkoret inte är längre är sant. Man till exempel beskriva läsandet av en bok schematiskt med iteration 1: Öppna boken 2: Om det finns sidor kvar att läsa: 2.1: Läs en sida 2.2: Bläddra till nästa sida Kontrollera villkor 3: Stäng bok 4: Lämna tillbaks boken till biblioteket Essensen i en iteration kan man se i exemplet består av tre beståndsdelar. 1. Iterationsvillkor ( 2: Finns det sidor kvar att läsa ) 2. Sats som påverkar iterationsvillkoret, tar iterationen närmare slutförandet. ( 2.2: Bläddra till nästa sida )
3. Den sats som ska itereras. ( 2.1: Läs en sida ) Man skulle även kunna ta med den första satsen 1: Öppna boken, som möjliggör iterationen. Denna typ av sats som förbereder iterationen kallas för initieringssats. När man diskuterar iterationssatser i programkod kallar man dom ofta för "loopar". De iterationssatser som finns i kan delas in i två kategorier, nämligen Räknande loopar Villkorsloopar Exemplet ovan är ett typiskt exempel på en stegande loop. Man kan betrakta det som att man tar steg från sidan 1 till sidan 2 till sidan 3 osv. till den sista sidan i boken. Skillnaden mellan dessa två typer av loopar är i huvudsak satsen som påverkar iterationsvillkoret. I exemplet är det satsen att bläddra till nästa sida, dvs. ta ytterligare ett steg i boken, som påverkar iterationsvillkoret. 1.3.1 for satsen En for sats är en av de vanligaste satserna i programkod och är mycket viktigt att behärska. Syftet med for satsen är att skapa räknande loopar. Formen för en for sats är for ( initieringslista; iterationsvillkor; inkrementsatslista ) sats / satsblock Man kan i formen skönja flera likheter med if satsen. Den stora skillnaden ligger i initieringslistan och inkrementlistan, och naturligtvis det faktum att for satsen är iterativ. Kom ihåg att en lista är noll, ett eller flera element separerade med kommatecken. Vi kan nu visa på bokexemplet först schematiskt med en forsats: for(öppna bok; om det finns sidor kvar att läsa; bläddra till nästa sida ) Läs en sida; Stäng bok; Lämna tillbaka boken till biblioteket; Detta är principen bakom varje forsats. Denna typ av kod kallas för pseudokod och används med fördel om man vill diskutera programkodslösningar. En C++ kompilator förstår naturligtvis inte pseudokod, använd penna och papper istället. Bokexemplet som ett komplett program Det går att skapa ett enkelt komplett program av bokexemplet, om man på förhand bestämmer antalet sidor i boken. Vi fastställer härmed att antalet sidor är 12.
#include<iostream> using namespace std; int main() int antal_sidor = 12; cout << "Öppnar boken"<<endl; for( int nuvarande = 0; nuvarande < antal_sidor; nuvarande++) cout<<"läser en sida i boken"<<endl; cout<<"stänger boken"<<endl; cout<<"lämnar tillbaks boken till biblioteket"<<endl; return 0; Detta bokexempel läser naturligtvis inte igenom någon riktig bok, men visar ändå ganska tydligt hur iterationen fungerar. Programmet följer exakt samma ordning som det schematiska exemplet ovan utan forsats. Då programmet körs utförs följande satser i tur och ordning Rad 6: Heltalsvariabeln antal_sidor initieras till 12 Rad 7: Texten "Öppnar boken" skrivs till skärmen Rad 8: Heltalsvariabeln nuvarande initieras till noll. Detta är alltså en initieringslista med ett element. Variabeln nuvarande kallas allmänt för loopvariabel. Rad 8: Iterationsvillkoret kontrolleras. Om villkoret nuvarande < antal_sidor, dvs ( här: 0 < 12 : sant ) är sant ( ja ), utförs satsblocket tillhörande for satsen. Rad 10: Texten "Läser en sida i boken" skrivs på skärmen Rad 8: Inkrementsatsen, nuvarande++, utförs. Variabeln nuvarande får alltså värdet 1 Rad 8: Iterationsvillkoret kontrolleras. Nu kan villkoret läsas som 1 < 12 : sant, och satsblocket tillhörande for satsen utförs. Rad 10: Texten "Läser en sida i boken" skrivs på skärmen Rad 8: Inkrementsatsen, nuvarande++, utförs. Variabeln nuvarande får värdet 2 Iterationen fortsätter på detta vis med villkor, satsblock, inkrement, villkor, satsblock, inkrement osv. tills dess att villkoret inte längre är uppfyllt. Detta inträffar då variabeln nuvarande fått värdet 12. Satsutvärderingen blir då vid den sista iterationen Rad 8: Inkrementsats, nuvarande++ ger variabeln värdet 12. Rad 8: Iterationsvillkoret gör jämförelsen, nuvarande < antal_sidor (nu 12<12: falskt). Eftersom villkoret inte längre är sant avbryts iterationen och fortsätter med Rad 12: cout<<"stänger boken"<<endl; Rad 13: Skriver till skärmen "Lämna tillbaks " Satserna i programmet utförs i exakt samma ordning som i det första schematiska bokexemplet utan for sats.
Övning: Övertyga dig själv om att det första schematiska exemplet fungerar på samma sätt som for satsen i exemplet ovan Iterationsvariabeln Betrakta programavsnittet for( int i=0; i< 10;i++) cout<<"i = "<< i <<", "; cout satsen i satsblocket skriver ut texten "i = ", därefter värdet på variabeln i, därefter ett kommatecken. Eftersom satsen står i en forsats kommer iterationsvillkoret och inkrementsatsen att avgöra hur många gånger cout <<.. utförs. Om man kör ett komplett program med ovanstående forsats kommer man att få följande utskrift, observera särskilt start och slutvärdet på i. i = 0, i = 1, i = 2, i = 3, i = 4, i = 5, i = 6, i = 7, i = 8, i = 9, Press any key to continue Det som är särskilt intressant i denna forsats är hur iterationsvariabeln kan användas inuti forsatsen. Detta är en mycket användbar egenskap, i synnerhet vid olika typer av beräkningar. Om man sätter ett endl sist i cout satsen kommer det att skrivas ut på tabellform. Denna typ av utskrift tillsammans med formatering av tal beskrivet i avsnittet utskrift ger ett bra sätt att skriva ut tabeller med beräkningar. Exempel, summaberäkning med for sats Antag att vi vill beräkna summan av serien 1+2+3+4+5+6+7+8+9+ +100 Utformning av lösning: De olika termerna i summan kan räknas fram med hjälp av for satsen. För att beräkna summan krävs ytterligare en variabel av heltalstyp, (int) + (int) ger resultat av typen int. Startvärdet i for satsen skall vara 1. Iterationsvillkoret skall vara utformat så att den sista iteration som utförs, skall vara för värdet 100. int total_summa = 0; // viktigt att nollställa for( int i = 1; i< 101; i++) total_summa += i; // öka total_summa med värdet på i cout<< "summan är:" << total_summa<<endl; Rad 1: Om man glömmer bort att nollställa total_summan kan man få helt oväntade resultat. Rad 2: Initieringssatsen låter värdet på i börja med 1 eftersom summeringen skulle börja med termen 1. Rad 2: Iterationsvillkoret ska medge att satsblocket utförs för värdet i = 100 men inte i = 101, villkoret avbryter nu vid jämförelsen 101 < 101.
Rad 4: Operatorn += används för att öka på värdet på variabeln total_summa med värdet av i. Kom ihåg utvärderingsordningen: initiering, villkor, satsblock, inkrement, villkor, satsblock, inkrement, villkor, satsblock, inkrement, villkor Resultatet blir: summan är:5050 Man kan även skriva for satsen med båda variabeldeklarationerna i initieringslistan for ( int total_summa = 0, int i = 0; i < 101; i++)... med samma resultat. Man bör undvika att lägga onödiga deklarationer i initeringslistan till forsatsen eftersom det kan försämra läsbarheten hos programmet. 1.3.2 Övning Skriv ett program som skriver ut treans multiplikationstabell upp till 10. Programutskrift 1*3 3 2*3 6 3*3 9 Tips: Skriv ut varje värde som en utmatning i en for sats, låt iterationsvariabeln stega från 1 till 10. Tecknen "*3 " på varje rad kan skrivas ut som vanlig text. Formatera utskriften med cout.width( ). 1.3.3 while och do while satserna Den andra typen av iterationssatser är villkorsloopar. Skillnaden mellan dessa satser och forsatsen är att de används när man inte utför en räknande iteration, i synnerhet då man på förhand inte känner till hur många iterationer som ska utföras. Ett vanligt förekommande sammanhang för dessa iterationer är för felkontroll av inmatningar från användaren. Villkorslooparna kommer två olika varianter, en med preevaluering, while, och en med postevaluering, do while. Preevaluering innebär att ett villkor utvärderas innan ett satsblock utförs medan postevaluering innebär att ett villkor utvärderas efter ett satsblock utförs. While satsen While satsen använder preevaluering dvs. först utvärdera villkor därefter utförs tillhörande satsblock. Formen på en while sats är följande while ( iterationsvillkor ) sats / satsblock Funktionen hos satsen är densamma som hos for satsen, men den saknar både initieringslista och inkrementsatslista.
Exempel, inmatning av en födelsemånad. Programmet ska ta emot en inmatning om vilken månad som användaren är född i och därefter konstatera om användaren föddes tidigt på året eller sent på året. Programmet innehåller en felkontroll av inmatad månad. En programkörning kan se ut som Vilken månad är du född? Ange ett tal mellan 1 och 12. 19 Du har angett ett felaktigt tal, försök igen! 4 Du har angett ett felaktigt tal, försök igen! 2 Du är född tidigt på året. Programlösning #include<iostream> using namespace std; int main() int fodelse_manad; cout<<"vilken månad är du född? Ange en siffra mellan 1 och 12."<<endl; cin>> fodelse_manad; // felkontroll while( fodelse_manad < 1 fodelse_manad > 12 ) cout<<"du har angett ett felaktigt tal, försök igen!"<<endl; cin>> fodelse_manad; // slut felkontroll if ( fodelse_manad <=6 ) cout <<"Du är född tidigt på året"<<endl; else cout <<"Du är född sent på året"<<endl; return 0; Observera att det finns två satser för samma inmatning i programmet, en före iterationen och en inuti iterationen. Inmatningssatsen inuti iterationen kommer bara att utföras om man har matat in ett felaktigt värde vid den första inmatningen. For satsen som while sats For satsen och while satsen skiljer sig bara på for satsens initieringslista och dess inkrementlista. Eftersom en lista kan bestå av inget element är det syntaktiskt korrekt att helt utelämna dessa satser. Gör man det får man exakt samma funktion som hos while satsen. Exemplet ovan hade även kunnat skrivas med for sats genom att byta ut while satsen mot
for ( ; fodelse_manad < 1 fodelse_manad > 12 ; )... som tidigare Observera att for satsens semikolon inte får utelämnas. Do while satsen #include<iostream> using namespace std; int main() int fodelse_manad; Do while satsen har ett samma funktion som while satsen med den skillnaden att den använder sig av postevaluering, villkoret om att fortsätta iterationen utförs efter det tillhörande satsblocket. Det får till följd att satsblocket till en do while sats alltid kommer att utföras minst en gång. Formen på en do while sats är do sats / satsblock while ( iterationsvillkor ); Exemplet ovan skrivet med en do while sats kan bli do cout<<"vilken månad är du född? "; cout<<"ange en siffra mellan 1 och 12."<<endl; cin>> fodelse_manad; while( fodelse_manad < 1 fodelse_manad > 12 ); if ( fodelse_manad <=6 ) cout <<"Du är född tidigt på året"<<endl; else cout <<"Du är född sent på året"<<endl; return 0; I denna variant finns det bara en sats som tar emot inmatningen av månaden, så programkoden är något enklare, men användaren får heller inget tydligt felmeddelande att inmatningen som gjordes var felaktig. En programkörning kan se ut som Vilken månad är du född? Ange ett tal mellan 1 och 12. 92 Vilken månad är du född? Ange ett tal mellan 1 och 12. 8 Du är född sent på året.
#include<iostream> using namespace std; Exempel, nästlade loopar, multiplikationstabellen På samma sätt som en villkorssats kan innehålla vilken annan sats som helst kan iterationssatser även innehålla iterationssatser. Det blir då en sk. nästlad iteration. Ett tydligt exempel på hur det kan fungera är multiplikationstabellen int main() for( int i = 1; i <= 10;i++) // anger raden i tabellen for( int j = 1; j <= 10;j++) // skriv ett tal i tabellen cout.width( 5 ); cout << i*j ; cout<< endl; /// nästa rad i tabellen return 0; Observera indenteringen (indraget) av programkoden i forsatserna. Resultatet blir 1 2 3 4 5 6 7 8 9 10 2 4 6 8 10 12 14 16 18 20 3 6 9 12 15 18 21 24 27 30 4 8 12 16 20 24 28 32 36 40 5 10 15 20 25 30 35 40 45 50 6 12 18 24 30 36 42 48 54 60 7 14 21 28 35 42 49 56 63 70 8 16 24 32 40 48 56 64 72 80 9 18 27 36 45 54 63 72 81 90 10 20 30 40 50 60 70 80 90 100 Press any key to continue Observera att rad 12: cout << i*j ; bara skriver ut ett tal åt gången, och resultatet innehållet en utskrift av hundra tal. cout satsen måste alltså ha utförts hundra gånger. Detta kommer sig av att den ena for satsen ligger i den andres satsblock. För varje gång som den första for satsen (rad 6) repeterar sitt satsblock kommer den inre for satsen (rad 8) att utföra cout satsen 10 gånger, vilket ger totalt hundra repetitioner av rad 12 14. 1.3.4 Övning Skriv multiplikationsprogrammet så att det använder while satser istället.