Rijen en reeksen.

Stelt u zich even voor dat u een programma moet schrijven dat 100 vragen bevat. Die vragen moeten één voor één op het scherm verschijnen, waarna de gebruiker moet kiezen uit een lijst van mogelijke antwoorden. Een enquete of een multiple choice examen, bijvoorbeeld. Nu kunt u natuurlijk de vragen bijhouden in tekstvariabelen (strings, meer daarover later) met als naam: vraag1, vraag2, … , vraag100. En de antwoorden van de gebruikers kunt u opslaan in antwoord1, antwoord2, antwoord3, … tot en met antwoord100. Dat zijn dus 100 cout en 100 cin statements die u moet schrijven, en dan hebben we ‘t nog niet over de verwerking gehad. Als het een examen is, moet u 100 if statements schrijven, om te zien of de antwoorden juist waren, bij de verwerking van de enquete moet u misschien nog veel meer gaan doen met die 100 variabelen. Een onbegonnen zaak, natuurlijk. Gelukkig, C++ heeft meerdere oplossingen voor een dergelijk probleem. Eén van de best bekende (die in alle programmeertalen terug te vinden zijn) zijn arrays. Een array is gewoon een reeks van gelijkaardige variabelen (allemaal int of double, bijvoorbeeld).

Omdat we al met gemiddelde werkten, zullen we een testje simuleren uit de statistiek. We gaan met een dobbelsteen gooien. Normaal gezien is de kans op een bepaald cijfer bij een dobbelsteen 1/6. Als we 60 keer gooien zou je verwachten van 10 enen, 10 tweeën, enzovoort te hebben. Hoe meer keer je gooit, hoe dichter we bij die theoretische 16.666… % voor elk cijfer zouden moeten komen. Om de dobbelsteen te simuleren, maken we gebruik van een randomgenerator. Randomgeneratoren worden vaak gebruikt in programma’s, zeker in spelletjes, maar ook in meer serieuze simulaties.

Een voorbeeld van het programma in actie:

Laten we er eens naar gooien.

De code:

Ons gokprogramma.

Op lijn 2 doen we een include van time.h. Dat hebben we nodig, omdat we straks een tijdsfunctie gaan gebruiken, en die is daar te vinden.

Lijn tien geeft de maximum waarde die een random getal kan aannemen op uw systeem weer. Dat kan al eens verschillen, en daarom wordt deze waarde vastgelegd voor u, in de constante (bemerk de hoofdletters) RAND_MAX.

Lijn 12 bevat de seed instructie. Om iedere keer dat we het programma draaien een andere “random” waarde te krijgen, moeten we de randomfunctie een startgetal of “seed” meegeven. Dat gebeurt hier met de functie srand. Als seed gebruiken we hier gewoon de huidige tijd van de computerklok. Die is namelijk iedere keer anders, wat ons ook garandeerd dat we altijd een andere willekeurige reeks getallen krijgen. Zet deze instructie in commentaar, en u zult merken dat u steeds dezelfde randomgetallen krijgt, bij iedere run.

Terzijde, een computer kan niet echt randomgetallen genereren, wel pseudorandomgetallen. Er zit een algoritme achter, dus echt willekeurig kan per definitie niet. Vandaar ook dat u zonder seed steeds dezelfde reeks krijgt. Er is nogal wat geschreven over het genereren van randomgetalllen met computers.

Lijnen 18 en 19 definiëren de constante AANTAL_GOOIEN. Zet één van de 2 in commentaar om verschillende aantallen te proberen (hoe groter, hoe dichter bij de theoretische uitkomsten). Ik gebruik een long int als type. Ieder type (int, double, etc…) heeft zo zijn beperkingen. Ook dat kan weer schelen van computer tot computer, maar in ANSI C++ (een standaard) heeft een int een gegarandeerde maximumgrootte van 2^16 = 65536. Echter, de eerste bit (bij signed integer, tenminste) is een tekenbit, zodat we in een integer een waarde kwijt kunnen tussen ongeveer -32000 en +32000 (de helft dus van ‘t voorgaande). De meeste compilers staan grotere getallen toe in het int type, maar daar is geen garantie op. Long integer is 2^32 groot, gegarandeerd. Veel groter dus, en ik speel hier op veilig, want ik zet de constante op 50000000, wat normaal te groot is voor een gewoon integer type. Dus gebruiken we long int. Maak u maar geen zorgen als u niet alles hiervan snapt. Onthou gewoon dat als je een te groot getal in een int steekt, de computer daar gewoon een stuk van kwijtspeelt, het potje loopt als het ware over, en dat dat rare gevolgen kan hebben. Zo is er ooit een raket neergestort vanwege een dergelijke programmeerfout. Iets om in het achterhoofd te houden als je voor de ESA of NASA ofzo gaat programmeren.

Lijn 21 bevat de definitie van een array. In dit geval dus een array van type long int (we spelen andermaal op veilig), die zes plaatsen bevat. De instructie is: long in waarde[6] = {0}. De 6 slaat dus op het aantal long integers, en we initialiseren alle 6 de waarden op 0. Er zijn verschillende manieren om arrays te initialiseren, we zullen er nog wel een aantal tegenkomen in de loop van de cursus. Een eigenaardigheidje is dat C++ (en zowat alle andere programmeertalen) begint te tellen vanaf 0. We hebben dus 6 variabelen met de naam waarde en elk een nummer, waarvan de eerste waarde[0] en de laatste waarde[5] heet. Dit is iets wat bij veel mensen in het begin voor verwarring zorgt.

Lijn 23 definieert de for lus, en dus meteen hoeveel keer we met de dobbelsteen gaan werpen (of dit althans gaan simuleren). Dit is afhankelijk van de waarde die we in de constante AANTAL_GOOIEN gedefinieerd hebben.

Op lijn 25 gebruiken we de functie rand, die niets anders doet dan een randomgetal in de variabele randomwaarde steken.

Lijn 26 bevat een nieuwe operator, namelijk de % of modulo operator. Modulo geeft in feite niets anders dan de rest bij deling terug. Zo is 7%2 = 1 want 7/2 is 3 met rest 1. Hier delen we modulo 6, de rest kan dus nooit groter zijn dan 5. Als het getal deelbaar is door 6, is de ret natuurlijk 0. We krijgen dus een waarde die van 0 tot 5 kan lopen, maar omdat dobbelstenen getallen van 1 tot 6 produceren, tellen we daar eentje bij op, en steken het resultaat in de variabele dobbelsteen.

Op de volgende lijn zien we dan waarde[dobbelsteen – 1] = waarde[dobbelsteen – 1] + 1 staan. We willen in de array waarde namelijk bijhouden hoeveel keer we 1, 2, 3, 4, 5 of 6 gegooid hebben. In de eerste waarde in de rij – waarde[0] dus (we beginnen vanaf 0 bij arrays) – houden we het aantal gegooide enen bij, in de tweede waarde – waarde[1] – het aantal tweeën, enzoverder… Vandaar dus dat we dobbelsteen – 1 schrijven. Als we een 1 gooien, staat daar dus in feite: waarde[1-1] = waarde[1-1] +1. We tellen dus 1 bij, bij de waarde die in waarde[0] zat.

Nadat we AANTAL_GOOIEN keer gegooid hebben gaan we verder met het programma.

Op lijn 39 definiëren we een for lus waarmee we in eerste isntantie kijken hoeveel keer we ieder oog van de dobbelsteen gegooid hebben. Dat doen we met de cout instructie die de waardes in waarde[0 tot 5] weergeeft. Moesten we een variabele waarde hebben die 1000 getallen bevat, dan zouden we hier niet meer code moeten schrijven, enkel de for lus zou moeten aangepast worden: inplaats van i < 6 zouden we moeten schrijven i < 1000. Een heel verschil met 1000 cout instructies moesten we 1000 aparte variabelen gebruikt hebben in plaats van een array.

Op lijn 45 berekenen we het totaal aantal ogen die er gegooid zijn (in feite: waarde[0] * 1 + waarde[1] * 2 + … + waarde [5] * 6. Dit gebeurd nog steeds binnen de lus. Moesten we aparte variabelen gebruiken, dan dienden we hier 6 getallen op te tellen. In het geval van 1000 verschillende variabelen, zou dat een optelling worden van een paar bladzijden lang.

Ik hoop dat hiermee het belang en het gemak van arrays enigszins aangetoond is.

Nog een belangrijk detail. C++ controleert niet of u de juiste grenzen gebruikt voor uw array. In ons geval zijn de grenzen 0 en 5. Maar ik kon ook iets geschreven hebben als waarde[15] = 100. C++ zou daar niets over zeggen, maar het zou wel nefast zijn voor de uitvoer van mijn programma. Dat komt omdat ik bij de definitie 6 geheugenplaatsen gereserveerd had. Na die gereserveerde plaats komt andere data, of zelfs programmacode. Met de foutieve instructie aarde[15] = 100 schrijf ik in feite de waarde 100 in een stuk geheugen waar ik moet uitblijven. Dat kan erg rare gevolgen hebben, en het is vrijwel zeker dat het programma gaat crashen. Dit is definitief iets waar je zeker altijd moet op letten, dat je nooit of te nimmer de grenzen (boundaries) van een array overschrijdt. Onthou het!

U kunt de code hier downloaden, deze is voorzien van extra commentaar.

Vragen kunnen gesteld worden op het forum – op het C++ board.

Opdracht

• Maak een nieuw project aan, met daarin een file “main”. Noem het “project_1.8”.
• Typ het programma over en compileer.
• Pruts er wat mee. 🙂

Details…

Nog wat voorbeelden van for lussen, en wat je er mee kunt aanvangen. En verder nog een woordje over constanten, en iets over speciale karakters in C++.

Een voorbeeld van het programma in actie:

Nog wat fun met for lussen.

De code:

Functie main van prject_1.7;

Op lijn tien zien we iets nieuws: “\n” op het einde van de string (tekst) in de cout instructie: “Optellen:\n”. Dit (die “\n” dus) is een controlekarakter. Dit zorgt voor een nieuwe lijn, en doet dus hetzelfde als endl, wat we in vorige programma’s gebruikten.

Er zijn nog meer van die controlekarakters of escapesequences zoals ze in ‘t engels heten. Een paar andere zijn \t (tab), \a (beep, een pieptoon), \r (carriage retrun), \b (backspace), …

Een backslash (\ dus) voor een karakter zetten maakt er een “escaped” karakter van. Op die manier kun je ook aanhalingstekens in een tekst krijgen. Bijvoorbeeld: cout << “Hij zei: \”hallo!\”.”

Op lijnen 11 en 12 zien we een for blok. Maar eigenaandig genoeg zien we geen haakjes ({}). Als er slechts 1 instructie voorkomt in het for blok, zijn de haakjes niet verplicht. Het is echter een goede gewoonte om ze toch te zetten. Dat is doorgaans duidelijker. Er zijn nog wat andere instructies waar dat ook lukt, zoals een if instructie. Maar herinner u, slechts de eerste opdracht na de instructie behoort tot het instructieblok. Als u meerdere instructies witl uitvoeren (zoals lijn 26 & 27), dan dient u wel degelijk de haakjes te gebruiken. Maak het uzelf makkelijk en gebruik ze altijd.

Nog op lijn 11 zien we ++i staan in de for instructie. Dat doet in essentie hetzelfde als i++. Er is echter wel degelijk een verschil: staat de + of – voor de variabele, dan wordt die eerst gewijzigd (respectievelijk +1 of -1), staat de + of – na de variabele, dan wordt die nadien gewijzigd (dus weer + of – 1).

Probeer volgend stukje code maar eens uit:

int voor = 10;
int na = 10;
int som1 = 5 + na++;
int som2 = 5 + ++voor;
cout << som1 << endl;
cout << som2 << endl;

De variabele som1 bevat 15 (en de variabele na bevat 6), maar de variabele som2 bevat 16 (en de variabele voor bevat 6). Bij som2 werd dus eerst de variabele voor met ééntje verhoogd, en werd dan pas de optelling gedaan. Bij som1 was er eerst de optelling, en pas daarna werd de variabele na met ééntje verhoogd. Dit is een bron van veel subtiele fouten in programma’s. Hou dit in het achterhoofd!

Lijn 24 bevat null statements. U merkt dat niet alles in de for lus ingevuld werd. Dit werkt, maar is ook een niet zo duidelijke constructie. Ook een afrader.

Op lijnen 31 & 32 definiëren we 2 constanten, met het keyword “const”. Constanten zijn wat de naam zegt: constant. Men kan ze 1 keer definiëren, en men moet ze meteen een waarde geven. De constanten kunnen daarna niet meer gewijzigd worden. Constanten zijn vooral handig om grenzen aan te geven, of een aantal waarden vooraf te definiëren die verder in het programma gebruikt worden (een voorbeeld zou kunnen zijn: const double PI = 3.1415926). Door dergelijke waarden als constanten de definiëren voorkomt men dat ze per ongeluk gewijzigd worden in de loop van het programma (door een programmeerfout).

U kunt de code hier downloaden.

Vragen kunnen gesteld worden op het forum – op het C++ board.

Opdracht

• Maak een nieuw project aan, met daarin een file “main”. Noem het “project_1.7”.
• Typ het programma over en compileer.
• Pruts er wat mee. 🙂

Waar of niet waar? Mijnheer Boole.

Het werk van de heer Boole is van groot belang voor de computerwetenschappen en de digitale elektronica. In dit programma zullen we daar een glimp of 2 van opvangen.
We berekenen weer gemiddelden, maar nu van rationele getallen (type double dus). En we introduceren een variabele van het type bool ofte boolean (hint).

Een voorbeeld van het programma in actie:

Gemiddelde van double getallen.

De code:

Ode aan George Boole.

Op lijn tien definiëren we de booleaanse variabele “vlag”. We initialiseren hem meteen met de waarde false. Een vlag is iets wat veel gebruikt wordt in software, het is onder meer een manier om aan te geven of iets al dan niet gebeurd is. Booleaanse variabelen kunnen enkel de waarde “true” of “false” bezitten. Hoewel… C++ is, in tegenstelling tot veel andere talen nogal flexibel wat dat betreft, de waarde “false” is eigenlijk gelijk aan nul, en alles wat niet nul is, is “true” (doe maar eens een cout van vlag, ergens tussendoor). Toch is het aan te raden om steeds expliciet “true” of “false” te schrijven, dat maakt het programma een stuk leesbaarder (voor mensen dan, voor de computer maakt het niet uit).

De volgende interessante lijn is lijn 20. Zoals we reeds weten gebruiken we een if…else constructie om beslissingen te nemen, aan de hand van een voorwaarde die waar of vals kan zijn. Wat tussen de haakjes staat na een if – in dit geval: !(cin >> invoer) – resulteert altijd (na evaluatie door de computer) in een booleaanse waarde, “false” of “true” dus. Als het “true” is, wordt het if blok uitgevoerd, als het “false” is, wordt het else blok uitgevoerd, tenminste als er een else blok is. De else instructie is namelijk niet verplicht maar optioneel bij een if instructie. Zonder else wordt dan gewoon de eerstvolgende instructie na het if blok verwerkt. We zien nog wel voorbeelden, dus geen zorgen maken. 🙂

De voorwaarde !(cin >> invoer) is in feite nogal een complexe instructie op zich. Binnen de haakjes zien we: cin >> invoer. Dat wil dus zeggen dat we de invoerstroom (wat u intikt) doorgeven aan de variabele invoer. De variabele invoer is van het type double, dus zolang als u double getallen (en integers, want die passen ook in double) ingeeft, is er niets aan de hand. De functie cin geeft echter niet alleen de input door aan een variabele, het geeft ook een booleaanse waarde terug. Als er niets fout loopt, u geeft netjes een getal in, dan zal cin een waarde “true” teruggeven, om te melden dat alles verliep zoals verwacht. Maar als u bijvoorbeeld een letter of een tekst wilt doorgeven aan de variabele invoer, dan zal cin een waarde false teruggeven, want een letter of een tekst past niet in een variabele van het type double. De operatie van het doorgeven faalt dus, en cin geeft een waarde “false” terug om dit aan te geven.

Met andere woorden, als u een getal ingeeft wordt de voorwaarde !(cin >> invoer) voor de computer gelijk aan !(true). In alle andere gevallen wordt de voorwaarde !(false).

Het uitroepteken is een negatie. Er staat dus: niet(true) of niet(false). Uiteraard is niet(true) == false en niet(false) == true.

De ganse voorwaarde is dus te lezen als: als er een fout gebeurt bij de invoer – we voeren geen getal in terwijl dat wel zou moeten voor het type double, dan zetten we de vlag op true in het if blok.

Men zou het if statement kunnen versimpelen door het wat uiteen te trekken:

bool geenfout = (cin >> invoer);
if(!geenfout)

De variabele geenfout bevat true als alles goed ging met de input, anders is hij false. Als er dus wel iets fout ging (!(geenfout)), zetten we de vlag op “true” in het if blok. Anders voeren we het else blok uit.

De voorwaarde van het do-while blok, op lijn 30 zorgt ervoor dat we het ganse do-while blok blijven herhalen zolang de variabele vlag de waarde “false” heeft, dus zolang er geen letter(s) ingevoerd werden.

Lijn 42 bevat ook een nieuwe instructie, de instructie system. Dit is de manier van C++ om systeemcommando’s op te roepen. Het commando “pause” is een windowscommando (net zoals bijvoorbeeld “dir”). Het stopt de uitvoer totdat u op een toets gedrukt hebt. Dit werkt niet in linux, omdat linux het commando “pause” niet kent. Het is ook niet nodig in linux, hoewel het de uitvoer van het programma niet zal hinderen als u het laat staan (u krijgt wel een foutboodschap).

U kunt de code hier downloaden.

Vragen kunnen gesteld worden op het forum – op het C++ board.

Opdracht

• Maak een nieuw project aan, met daarin een file “main”. Noem het “project_1.6”.
• Typ het programma over en compileer.
• Probeer uit te vissen wat u aan het programma zou moeten wijzigen als de instructies in het if en het else blok omgewisseld zouden zijn. U zet de vlag dus in het else blok, en doet de berekeningen in het if blok.

Nog meer lussen!

We hebben al de while en de do-while lussen gezien. Met deze twee hebben we meer dan genoeg om alle repeterende delen te programmeren. Bij beide soorten kun je allerlei voorwaarden stellen voor het beëindigen van de lus. Dat is zeker handig als je niet weet hoeveel maal een lus doorlopen moet worden, of als dat afhankelijk is van andere dingen in het programma. Er zijn echter ook veel gevallen waar we precies weten hoeveel keer we een lus willen doorlopen. En voor deze gevallen maken we gebruik van de for lus. Eigenlijk is een for lus niet meer dan een verkorte schrijfwijze van een while lus.

We illustreren het principe aan de hand van het volgende programma, dat verdacht veel lijkt op project_1.2.

Vierkanstwortels van even getallen kleiner dan 10.

Het programma ziet er als volgt uit:

De geheimen van de for lus.

Merk op dat we weer y niet initialiseren en dat de windows IDE daarover klaagt.

De enige lijn die we nog niet kennen is lijn 15. Daar wordt de for lus gedefinieerd. Eigenlijk spreekt het een beetje vanzelf wat er gebeurd. We schrijven: for (int x = 0; x < 10; x = x + 2).
Het keyword “for” definieert uiteraard een for lus. Alles wat tussen { en } staat is het for blok, net als bij het while en do-while commando.

We definiëren een aantal dingen in één keer, tussen de haakjes na het for keyword.

• Eerst komt int x = 0. We definiëren hier dus een variabele x van het type integer, en initialiseren die met de waarde 0.
• Dan komt de voorwaarde of test: x < 10, of x kleiner dan 10. Zolang x inderdaad kleiner is dan 10, zullen we de instructies binnen het for blok uitvoeren (trekken van de vierkantswortel en het resultaat op het scherm schrijven). Als x gelijk of groter is dan 10, stoppen we met het for blok en gaan we verder met de daaropvolgende instructie.
• Als laatste schrijven we x = x + 2. Dit statement zorgt er voor dat er telkens 2 bij de huidige waarde van x geteld wordt, zolang de lus loopt. Ook hier hadden we x++ kunnen gebruiken, maar dan zou er telkens slechts 1 bij x worden opgeteld (probeer maar eens!).

Merken we nog op dat de variabele x slechts bestaat binnen het for blok, omdat hij in dat blok gedefinieerd is. Algemeen kan men stellen dat een variabele alleen gekend is binnen het blok waarin hij gedefinieerd is. Moest u na de for lus proberen de waarde van variabele x op het scherm te tonen, dan zal uw programma niet compileren. U krijgt een fout, waar de computer u zegt dat x “out of scope” is. Meer over scope later.

Tips

• Typ het programma over. Dit helpt om de commando’s te leren, en je zult ze dan ook sneller onthouden.
• Als het programma niet wil compileren, kijk na of je alles precies hebt overgetypt, en kijk vooral na of je nergens een puntkomma vergeten bent.
• Maak u vooral geen zorgen als u niet alles direct begrijpt, dat komt wel. Als het echt niet gaat, schrijf u in op het forum en stel uw vraag daar.

U kunt de code hier downloaden, deze is voorzien van extra commentaar.

Vragen kunnen gesteld worden op het forum – op het C++ board.

Opdracht

• Maak een nieuw project aan, met daarin een file “main”. Noem het “project_1.5”.
• Typ het programma over en compileer.
• Probeer het projekt 1.2 te herschrijven, ook de opdracht, maar gebruik nu for lussen.
• Probeer eens een programma te maken dat de volgende uitvoer op het scherm zet (tip: gebruik 2 for lussen, de ene binnenin de andere, en gebruik de waarde van de variabele van de eerste for lus in de voorwaarde van de tweede lus). De oplossing staat bij de code download, maar niet valsspelen, eerst zelf proberen!

Sterretjes, met 2 for lussen ineen (geneste lussen).

Beslissingen…

Ons vierde programma is enigszins statistisch georiënteerd. Maak u geen zorgen, we gaan gewoon een gemiddelde berekenen. We beperken ons tot een gemiddelde van positieve gehele getallen. U kent het wel, neem ik aan.

Er zijn 2 mogelijke uitkomsten. Ofwel geeft men geen cijfers in, ofwel doet men dat wel. Hieronder de uitvoer in de twee gevallen.

Geen getallen ingegeven.

Getallen ingegeven.

De code is als volgt:

Het programma dat gemiddelden berekend.

Een belangrijk gegeven bij dit soort programma’s is dat de programmeur niet kan weten hoeveel getallen men wil ingeven. Men kan een gemiddelde willen berekenen van 5 getallen, maar netzogoed één van 100 getallen. Er moet dus een manier zijn voor de gebruiker om aan te geven dat alle gegevens ingevoerd zijn, en dat de berekening mag starten. In ons geval gebruiken we daarvoor het getal -1. De ingave van -1 is dus een stopconditie.

Op de lijnen 8, 9 en 10 definiëren we onze variabelen, en initialiseren we ze. Als we dat laatste niet doen staat daar iets willekeurig in, en dat zou in dit geval zeker tot fouten leiden. De variabele som definiëren we als double, omdat we een double als gemiddelde willen. Moest dit ook een integer zijn, dan zou ons gemiddelde altijd afgekapt worden tot een geheel getal, en dat is duidelijk fout (probeer het maar eens , maak van som een integer in plaats van een double, en bereken dan het gemiddelde van 1 en 2).

Bemerk dat lijn 12 eigenlijk verderloopt op lijn 13. Zolang de computer geen “;” tegenkomt is alles deel van dezelfde instructie. U zou ook een paar keer op ENTER kunnen drukken zodat er nog wat witregels tussen 12 en 13 zitten, dat maakt geen enkel verschil (probeer maar eens). Toch niet voor de computer. Misschien wel voor u, naar leesbaarheid van het programma toe.

Op lijn 16 zien we iets nieuws: cin >> invoer. Deze lijn zorgt ervoor dat de invoerstroom (wat u intypt) doorgegeven wordt aan de variabele invoer. Omdat invoer van het type integer is, wordt enkel integer invoer toegelaten. De ENTER die u indrukt blijft in de invoerstroom zitten (ENTER is voor de computer ook gewoon een code, net zoals cijfers en letters dat zijn, en dat teken blijft dus steken in de stroom). Moest u iets anders ingeven dan een geheel getal, dus letters of een decimaal getal, dan slaat het programma tilt. Voor de nieuwsgierigen onder u: CTRL + C samen indrukken stopt de waanzin. 🙂

Er zijn natuurlijk manieren om dit op te vangen, daarover later meer.

Op lijn 18 start een while blok, dat controleert of de gebruiker geen -1 ingegeven heeft (het teken != staat voor “niet gelijk aan”). Indien dus invoer niet gelijk is aan -1, dan wordt het while blok (tussen {}) uitgevoerd. Op lijn 20 tellen we 1 bij bij aantal, en op lijn 21 tellen we de waarde van invoer op bij die van som, en steken het resultaat terug in som. Lijn 23 behoeft intussen geen uitleg meer en lijn 24 is een nieuwe invoer. Daarmee gaan we terug naar lijn 18, waar gekeken wordt of invoer al dan niet -1 is. Indien niet, doen we alles nog eens over, indien wel, dan is dat het einde van het while blok en gaan we over naar de volgende instructie.

Lijn 27 spreekt ook voor zich, neem ik aan.

Op lijn 30 komen we voor het eerst de if instructie tegen. If is engels voor als, dus daar staat in woorden iets als: als aantal precies (==) gelijk is aan 0, doe dan het codeblok dat volgt. De variabele aantal is alleen 0 als er geen ingaves geweest zijn, dus als de gebruiker direct -1 heeft ingegeven. De instructie if kan echter uitgebreid worden met else. Anders dus. Als aan de voorwaarde niet voldaan is (aantal is niet nul), dan wordt het codeblok na de else uitgevoerd. In dat geval kunnen we een gemiddelde berekenen, en dat doen we dan ook. Bemerk dat we de berekening direct in de uitvoerstroom (de cout) doen. We hadden natuurlijk ook een double resultaat kunnen definiëren en het resultaat daarin steken, en dat dan laten afdrukken. Als we dat resultaat verder nog nodig hebben in ons programma is dat zelfs een beter idee, omdat we de berekening dan maar éénmaal moeten doen.

De extra cin.get() op lijn 30 dient om de ENTER op te vangen die nog in de inputstroom zat. Zet hem maar even in comentaar en dan ziet u wel wat ik bedoel (de linuxgebruikers zullen dat niet zien als ze niet zeer aandachtig zijn :-)).

Tips

• Typ het programma over. Dit helpt om de commando’s te leren, en je zult ze dan ook sneller onthouden.
• Als het programma niet wil compileren, kijk na of je alles precies hebt overgetypt, en kijk vooral na of je nergens een puntkomma vergeten bent.
• Maak u vooral geen zorgen als u niet alles direct begrijpt, dat komt wel. Als het echt niet gaat, schrijf u in op het forum en stel uw vraag daar.
• Probeer zelf dingen uit. Verander hier en daar iets, en zie wat het doet. Doet het wat u dacht dat het ging doen, of net niet? Probeer in dat laatste geval te achterhalen waarom niet. Wees niet bang om te ewperimenteren!

U kunt de code hier downloaden.

Vragen kunnen gesteld worden op het forum – op het C++ board.

Opdracht

• Maak een nieuw project aan, met daarin een file “main”. Noem het “project_1.4”.
• Typ het programma over en compileer.
• Probeer het eens te schrijven met een do-while lus in plaats van een while lus. Dat spaart u aan de ene kant misschien en paar regels code, maar aan de andere kant zult u iets moeten bedenken in verband met het aantal ingegeven waardes.

Meer lussen…

Ons derde programma introduceert nog een ander soort lus, de while lus. We bekijken het verschil met de do-while lus.

Hieronder ziet u wat het programma doet.

De uitvoer van ons programma.

En dit is de programmacode:

De code (main) van project_1.3.

We zullen het programma even analyseren.

Beginnen we met lijn 8, waar we de variabele y van het type double aanmaken. Merk op dat we er nog geen waarde aangeven. Toch zit er in die variabele wel een waarde. Zo’n variabele is immers gewoon een plaatsje in het computergeheugen, en de waarde die er bij de creatie inzit is wat daar op dat moment toevallig in staat. Vandaar dat je een variabele best meteen ook initialiseert (een waarde geeft dus), zelfs al is dat gewoon nul. Als je dat vergeet, kan je programma foutieve zaken doen omdat de computer werkt met die willekeurige waarde die in eerste instantie in de variabele zit. De IDE van microsoft weet dit en geeft u zelfs een waarschuwing als u wil compileren.

Waarschuwing: variabele y werd niet geïnitialiseerd!

U kunt hier gewoon doorgaan, we weten wat we doen, nietwaar? Op lijn 10 wordt de waarde van y afgedrukt. Dit kan eender welke waarde zijn, wat er toevallig op die plaats in het geheugen zit.

Op lijn 16 begint het do-while blok. We hebben daarvoor x de waarde 10 gegeven, maar toch gaat de computer het do-while blok uitvoeren, al is x niet kleiner dan 10. Dat komt omdat bij het do-while blok de controle pas op het einde plaatsvindt. Lijn 18 en 19 worden dus vrolijk uitgevoerd, maar slechts 1 maal. Bij controle op lijn 21 blijkt x niet kleiner te zijn dan 10, en wordt het do-while blok niet meer herhaald, er wordt overgegaan naar de volgende lijn code.

De volgende lijn drukt de waarde van x af. Die is intussen 11, als gevolg van lijn 19.

Lijn 25 bevat de start van het while blok. Hier wordt de controle eerst gedaan, en pas daarna kan het blok doorlopen worden, als aan de voorwaarden voldaan is. Hier si dat echter niet het geval, aangezien x (=11) niet kleiner is dan 10. De lijnen 27 en 28 van het while blok zullen dus niet uitgevoerd worden door de computer. Dit blijkt als men de waarde van x nogmaals afdrukt (lijn 31), die is nog steeds gelijk aan 11, ondanks het x++ statement op lijn 28.

Tips

• Typ het programma over. Dit helpt om de commando’s te leren, en je zult ze dan ook sneller onthouden.
• Als het programma niet wil compileren, kijk na of je alles precies hebt overgetypt, en kijk vooral na of je nergens een puntkomma vergeten bent.
• Maak u vooral geen zorgen als u niet alles direct begrijpt, dat komt wel. Als het echt niet gaat, schrijf u in op het forum en stel uw vraag daar.

U kunt de code hier downloaden, deze is voorzien van extra commentaar.

Vragen kunnen gesteld worden op het forum – op het C++ board.

Opdracht

• Maak een nieuw project aan, met daarin een file “main”. Noem het “project_1.3”.
• Typ het programma over en compileer.
• Probeer het vorige projekt (1.2) te herschrijven, maar gebruik nu while lussen in plaats van do-while lussen.

Tweede programma

In ons tweede programma zien we meteen een aantal belangrijke zaken die in elke programmeertaal voorkomen. Het programma op zich is eenvoudig genoeg. Het toont u een lijstje met de vierkantswortels van de getallen 0 tot 9.

De vierkantswortels van 0 tot en met 9.

project_1.2, main.cpp

We zullen het programma even analyseren.

De lijnen 1 t.e.m. 3 bevatten includes. De instructie include laat de computer stukken code die voorgeprogrammeerd zijn inladen. In dit geval is het code die bijgeleverd is, maar het kan net zo goed uw eigen code zijn. Lijn 1 laadt de bibliotheek iostream in, nodig voor input en output. Lijn 2 zorgt er voor dat de bibliotheek cmath ingeladen wordt. Op die manier kunt u gebruik maken van bepaalde (voorgeprogrammeerde) mathematische functies, zoals de vierkantswortel, sinus, cosinus, … in uw programma. Lijn 3 laadt de standard library. Dit is enkel nodig als u linux gebruikt, onder windows hoeft u die niet expliciet te laden.

Lijn 5 maakt ons het leven wat makkelijker, we geven aan dat de functies die we gebruiken meestal uit de standard library komen. Moesten we deze lijn niet hebben (zet ze eens in commentaar (met //) om het te proberen), zouden we steeds std::cin en std::cout moeten schrijven in plaats van gewoon cin en cout. Idem voor alle andere functies die uit de standard library komen (zoals bijvoorbeeld endl). Als u “std::” typt, dan zult u ook zien dat uw IDE (ofwel Microsoft Visual C++ ofwel NetBeans) u helpt, u krijgt namelijk een lijstje te zien met alle mogelijke functies die na std:: kunnen komen. Handig!

Lijn 7 is het begin van het eigenlijke programma, de functie main. Zoals al eerder aangegeven, moet ieder C++ programma een functie main hebben. Alles wat tussen de eerste { en de laatste } staat maakt deel uit van main. Wat tussen dergelijke haakjes staat is een blok code.

Op lijn 9 definiëren we de variabele x. Deze x is van het type integer. Men kan een variabele het best vergelijken met een doos waar men iets kan instoppen. De C++ dozen zijn speciaal in die zin dat ze maar dingen van een welbepaalde soort kunnen bevatten. In dit geval kan in onze doos een geheel getal zitten. Vandaar het type integer. We initialiseren x meteen op de waarde 0 (we steken dus een nul in de doos). We konden evengoed int x; x=0; geschreven hebben, definitie en initialisatie apart dus.

Het leeuwedeel van ons programma zit in de regels 11 tot 17. We zien weer een blok code (tussen { en }), en de woorden “do” en “while”. Dit staat dan ook bekend als een do-while blok. Zo’n blok zorgt voor herhaling, en dat is één van de fundamentele zaken in iedere programmeertaal.

Op lijn 13 definiëren we een ander soort variabele, de variabele y, van het type double. Variabelen van het type double kunnen decimale getallen bevatten. We kennen er ook meteen een waarde aan toe, namelijk de vierkantswortel van het getal dat zich momenteel in x bevindt (dat was dus 0). Dat doen we met de functie sqrt (uit de library cmath). Omdat sqrt enkel met een double type getal kan werken, en x een integer type is, moeten we x eerst omvormen naar double. Dat omvormen heet casten, en we doen dat door gewoon het type voor x te zetten (dus (double)x zorgt ervoor dat de functie sqrt een decimaal getal (een double) ziet). Meer over casten later.

Ik geef even mee dat de variabele y enkel bestaat voor de computer binnen het blok waar hij gedefinieerd is. Dus zolang de computer in het do-while blok bezig is, kent hij de variabele y. Buiten dat blok wordt deze variabele weer gewist. Men spreekt over de scope van een variabele. Dit is een belangrijk begrip, dat later nog aan bod komt.

De volgende lijn zorgt voor uitvoer naar het beeldscherm.

Lijn 15 is iets speciaals. We schrijven: x++. Wat dit doet is 1 bijtellen bij de waarde die in x zit. Dat was 0, het wordt dus 1. Dit is een verkorte versie van x = x + 1. Dit laatste doet net hetzelfde, men zou het kunnen lezen als: neem wat in doos x zit, doe er 1 bij, en steek het resultaat terug in doos x. Omdat het in programmeren behoorlijk vaak voorkomt dat je ergens eentje moet bijtellen, is daar een verkorte versie voor, namelijk x++. Nu mag u even raden wat x– doet (x gevolgd door 2 mintekens dus). 🙂

Lijn 17 is waar de controle gebeurd. Er staat: while (x<10). In woorden: zolang x kleiner is dan 10. Zolang x kleiner is dan 10, moet het blok code tussen do en while uitgevoerd worden. Dus krijgen we in y nu de vierkantswortel van 1 (x is nu 1), dat wordt afgedrukt, en dan tellen we 1 bij x, waardoor x=2 wordt. Enzoverder. Tot x=10 geworden is. Bij de controle x<10 merkt de computer dat x niet kleiner is dan 10, maar gelijk aan 10. Dat wil dus zeggen dat we moeten stoppen met de do-while lus, en verder moeten gaan met de eerstvolgende instructie.

De volgende lijn is 19, die de boodschap “Druk ENTER om te sluiten…” op het scherm schrijft. Lijn 20 wacht op een invoer, zodat het scherm niet meteen verdwijnt nadat een lijstje vierkantswortels afgedrukt werd (deze twee lijnen zijn overbodig in linux).

Op lijn 22 zien we return EXIT_SUCCES. EXIT_SUCCES is een zogenaamde cosntante (en die is hier 0, dus dit is gewoon hetzelfde als zouden wel return 0 geschreven hebben). Wat die constante is wordt gedefinieerd in de standard library, vandaar dat we ze moeten includen (lijn 3) in linux. Wat het return statement precies doet wordt binnenkort wel duidelijker.

Tips

• Typ het programma over. Dit helpt om de commando’s te leren, en je zult ze dan ook sneller onthouden.
• Als het programma niet wil compileren, kijk na of je alles precies hebt overgetypt, en kijk vooral na of je nergens een puntkomma vergeten bent.
• Maak u vooral geen zorgen als u niet alles direct begrijpt, dat komt wel. Als het echt niet gaat, schrijf u in op het forum en stel uw vraag daar.

U kunt de code hier downloaden, deze is voorzien van extra commentaar.

Vragen kunnen gesteld worden op het forum – op het C++ board.

Opdracht

• Maak een nieuw project aan, met daarin een file “main”. Noem het “project_1.2”.
• Typ het programma over en compileer.
• Wijzig het programma zo dat het de vierkantswortels van de getallen 2, 4, 6, 8 en 10 afdrukt, zoals in de figuur hieronder.
• Probeer of u de getallen in omgekeerde volgorde kunt laten afdrukken (dus beginnen met 10, dan 8, … ), zoals in de laatste figuur. U moet dus x laten aftellen in plaats van optellen, en stoppen als x kleiner wordt dan 0 (of doordoen zolang x groter of gelijk is aan 0, groter of gelijk kan men schrijven als >=) .

Vierkantswortels van even getallen van 0 tot 10.

Vierkantswortels van even getallen van 10 tot 0.

Eerste programma – linux

Met onderstaande figuren wordt uitgelegd hoe je een eerste programma maakt. Klikken op de respectievelijke prentjes toont je een grotere (en duidelijker) versie. Bekijk het aandachtig en voer dan de opdracht uit.

Een nieuw C++ projekt aanmaken - deel 1.

Een nieuw C++ projekt aanmaken - deel 2.

Alles wissen en nieuwe code intypen.

Compileren en runnen.

Om samen te vatten:

1. open Netbeans
2. kies menu File → New → Project
3. kies “C/C++” links en “C/C++ Application” rechts, klik op next
4. geef het project én de main file een naam (project_1.1 en main), klik op next
5. kies menu Project → Add New Item → C++ File (.cpp)
6. wis de code die er al staat
7. typ (of kopieer) de nieuwe code in het venster
8. compileer (menu Run → Run Main Project OF F6 OF de groene pijl op de toolbar)

Opdracht

• Maak een nieuw project aan. Noem het “project_1.1”.
• Maak vervolgens een file “main” aan.
• Typ onderstaand programma over en compileer.

#include <iostream>

using namespace std;

int main()
{
    cout << "Hoera! Mijn eerste programma !!" << endl;

    // de volgende twee lijnen zijn niet nodig in de linux omgeving
    cout << "Druk ENTER om te sluiten..." << endl;
    cin.get();

    return 0;
}

Tips

• Typ het programma over (in plaats van het gewoon te kopiëren). Dit helpt om de commando’s te leren, en je zult ze dan ook sneller onthouden.
• Als het programma niet wil compileren, kijk na of je alles precies hebt overgetypt, en kijk vooral na of je nergens een puntkomma vergeten bent.

U kunt de code hier downloaden, deze is voorzien van extra commentaar.

Vragen kunnen gesteld worden op het forum – op het C++ board.

Eerste programma – windows

In de onderstaande film wordt uitgelegd hoe je een eerste programma maakt.

Om even samen te vatten:

1. open Visual C++ 2010 Express
2. kies menu File → New → Project
3. kies “Empty Project” (dit is een snellere manier dan in het filmpje)
4. geef het project een naam en klik op OK (of druk op ENTER)
5. kies menu Project → Add New Item → C++ File (.cpp)
6. geef de file een naam (hier “main”) en klik op Add (of druk op ENTER)
7. typ (of kopieer) de code in het venster
8. compileer (menu Debug → Start Debugging OF F5 OF de groene pijl op de toolbar)

Opdracht

• Maak een nieuw project aan, zoals op de video. Noem het “project_1.1”.
• Maak vervolgens een file “main” aan.
• Typ onderstaand programma over en compileer.

#include <iostream>

using namespace std;

int main()
{
    cout << "Hoera! Mijn eerste programma !!" << endl;

    cout << "Druk ENTER om te sluiten..." << endl;
    cin.get();

    return 0;
}

Tips

• Typ het programma over (in plaats van het gewoon te kopiëren). Dit helpt om de commando’s te leren, en je zult ze dan ook sneller onthouden.
• Als het programma niet wil compileren, kijk na of je alles precies hebt overgetypt, en kijk vooral na of je nergens een puntkomma vergeten bent.

U kunt de code hier downloaden, deze is voorzien van extra commentaar.

Vragen kunnen gesteld worden op het forum – op het C++ board.

Installeer NetBeans met C++ support.

Degenen die niet met windows werken, kunnen de NetBeans IDE gebruiken. Hij is overigens ook beschikbaar voor windows, voor degenen die geen fan zijn van Visual Studio.

Informatie over het configureren van NetBeans voor het gebruik met C++ vind je hier.

Alle voorbeelden die niet exclusief windows zijn, zullen normaal gezien ook werken onder andere operating systemen. Ik test op Ubuntu linux.
Op Ubuntu kan men makkelijk de g++ compiler en de NetBeans IDE installeren via de synaptics pakket manager. Zie de prentjes hieronder (klik erop voor een grotere versie).

g++ installeren in ubuntu.

NetBeans installeren in ubuntu.