In deze les bespreken we de volgende onderwerpen:
Vorige keer hebben we het al gehad over variabelen. Een variabele is een naam die je geeft aan een plaats in het geheugen, zodat je daar gegevens op kunt slaan. In deze les gaan we uitgebreider in op variabelen en wat je ermee kunt doen.
De naam van de variabele mag je zelf verzinnen. Je bent daar redelijk vrij in, maar C++ legt een paar beperkingen op:
Wat betreft de laatste regel, sommige woorden hebben in C++ een speciale betekenis. Twee van die woorden die we al gezien hebben zijn using en namespace, in deze les komen we ook float en int tegen en later krijgen we nog een aantal waaronder if, for en while. Deze woorden mag je dus niet gebruiken als naam van je variabele.
Het is van groot belang dat je zinvolle namen kiest voor je variabelen; dat maakt het lezen van je broncode een stuk makkelijker. Als je de gebruiker vraagt om zijn voornaam, noem de variabele waarin je de naam opslaat dan myFirstName, vraag je om een werkwoord, noem de variabele dan myVerb. Gebruik nooit een naam als myVariable; dat is veel te algemeen en onduidelijk.
We spreken af dat we de naam van een variabele altijd beginnen met de letters my, gevolgd door een logische naam. We schrijven my dan met kleine letters en we beginnen de logische naam met een hoofdletter, bijvoorbeeld myVerb. Namen van variabelen mogen geen spaties bevatten, dus als de logische naam bestaat uit meerdere woorden, dan beginnen we elk woord met een hoofdletter en plakken we de woorden aan elkaar, bijvoorbeeld myFirstName.
Als we een variabele willen gebruiken, dan moeten we de compiler vertellen wat voor soort gegevens we in de variabele op willen slaan. Het soort gegevens noemen we datatype of kortweg type.
We hebben al gezien dat we om tekst op te slaan het type string gebruiken. Willen we werken met gehele getallen, dan hebben we het type int nodig. Gebroken getallen slaan we op in een variabele van het type float.
Voordat we een variabele kunnen gebruiken, moeten we kenbaar maken hoe de variabele heet en van welk type hij is. Hieronder zie je een aantal voorbeelden hiervan.
// reserveer geheugen om tekst op te slaan string myText; // reserveer geheugen om een geheel getal op te slaan int myInteger; // reserveer geheugen om een gebroken getal op te slaan float myFloatingPoint;
Bovenstaande statements vertellen de compiler dat we een variabele willen gebruiken, hoe de variabele heet en welk type gegevens we in de variabele willen opslaan. Een dergelijk statement heet een declaratie. We zeggen dat we met het statement string myText; de variabele myText declareren als een string. De declaratie van een variabele moet altijd gebeuren voordat de variabele voor het eerst gebruikt wordt.
We kunnen een gedeclareerde variabele een waarde geven op de manier die hieronder geïllustreerd wordt.
// declareer een variabele om tekst in op te slaan string myText; // geeft de variabele een waarde myText = "Hello, world!";
Met getallen werkt het net zo.
// declareer een variabele om een geheel getal in op te // slaan int myInteger; // geef de variabele een waarde myInteger = 101;
Omdat het heel vaak voorkomt dat je een variabele een beginwaarde wilt meegeven, kun je dit meteen doen tijdens de declaratie. We zeggen dan dat je de variabele initialiseert. Dat ziet er als volgt uit.
// initialiseer een tekst variabele met de tekst Hello, // world! string myText = "Hello, world!"; // initialiseer een geheel getal met de waarde 101 int myInteger = 101;
We weten inmiddels hoe we tekst naar het scherm kunnen schrijven en hoe we tekstinvoer van de gebruiker kunnen vragen, maar hoe werkt het met getallen?
Invoer en uitvoer van getallen is vrijwel gelijk aan de invoer en uitvoer van tekst. Het volgende programma schrijft een getal naar het scherm.
/* Programmeur: dhr. Ronkes Agerbeek Programma: Jaartal Omschrijving: Schrijft het huidige jaartal naar het scherm. */ #include <iostream> using namespace std; // het programma start hier void main() { // schrijf jaartal naar scherm cout << 2002; }
We kunnen ook een variabele met daarin een getal naar het scherm schrijven.
/* Programmeur: dhr. Ronkes Agerbeek Programma: Jaartal Omschrijving: Schrijft het huidige jaartal naar het scherm. */ #include <iostream> using namespace std; // het programma start hier void main() { // initialiseer variabele met huidige jaartal int myCurrentYear = 2002; // schrijf jaartal naar scherm cout << myCurrentYear; }
Ook invoer lezen van het toetsenbord levert geen verrassingen op.
/* Programmeur: dhr. Ronkes Agerbeek Programma: Jaartal Omschrijving: Vraag het huidige jaartal en schrijf het naar het scherm. */ #include <iostream> using namespace std; // het programma start hier void main() { // declareer variabele om huidige jaartal op te slaan int myCurrentYear; // lees huidige jaartal cin >> myCurrentYear; // schrijf jaartal naar scherm cout << myCurrentYear; }
We kunnen tekst en getallen moeiteloos met elkaar combineren.
/* Programmeur: dhr. Ronkes Agerbeek Programma: Jaartal Omschrijving: Vraag het geboortejaar van de gebruiker en toon geboortejaar en huidige jaartal. */ #include <iostream> using namespace std; // het programma start hier void main() { // declareer variabele om geboortejaar op te slaan int myBirthYear; // lees geboortejaar cout << "Wat is je geboortejaar? "; cin >> myBirthYear; // schrijf geboortejaar en huidige jaartal cout << "We leven in het jaar " << 2002; cout << " en je bent geboren in " << myBirthYear; }
Uiteraard zou het niet zo interessant zijn als we getallen alleen maar konden invoeren en uitvoeren. Rekenen behoort ook tot de mogelijkheden en de C++-compiler weet hoe hij moet optellen, aftrekken, vermenigvuldigen en delen. Zoals je gewend bent, gebruiken we symbolen om aan te geven welke bewerking we willen uitvoeren. Omdat niet alle symbolen voor zich spreken, volgt hier een overzicht.
operator |
omschrijving |
|---|---|
+ |
optellen |
- |
aftrekken |
* |
vermenigvuldigen |
/ |
delen |
% |
modulo (rest na deling) |
Deze symbolen noemen we operatoren. We hebben al eerder operatoren gezien, namelijk =, >> en <<. We spreken af dat in onze broncode links en rechts van elke operator een spatie komt te staan.
Rekenen met getallen gaat in C++ als volgt.
// initialiseer een getal om mee te rekenen int myNumber = 12; // schrijf de uitkomst van enkele sommen naar het beeld cout << "3 + 5 = " << 3 + 5 << endl; cout << "2 * 12 = " << 2 * myNumber << endl; cout << "12 % 7 = " << myNumber % 7;
Sommen die in de broncode staan zoals 3 + 5 en 2 * myNumber noemen we expressie en omdat we hier aan het rekenen zijn spreken we over rekenkundige expressies.
We kunnen de uitkomst van een rekenkundige expressie ook weer opslaan in een variabele.
// declareer een variabele om de uitkomst op te slaan int myResult; // reken som uit en sla antwoord op myResult = 3 + 5;
We kunnen zelfs een variabele gebruiken in een rekenkundige expressie en het resultaat van die expressie weer opslaan in dezelfde variabele.
// initialiseer een getal om mee te rekenen int myNumber = 12; // reken som uit en sla antwoord op myNumber = myNumber * 2;
Omdat dit soort bewerkingen - waarbij je de uitkomst opslaat in de variabele die ook in de expressie staat - vaak voorkomen, is er een verkorte schrijfwijze.
// initialiseer een getal om mee te rekenen int myNumber = 12; // tel 2 bij getal op myNumber += 2; // trek 4 van het getal af myNumber -= 4; // vermenigvuldig getal met 3 myNumber *= 3; // deel getal door 2 myNumber /= 2; // reken getal modulo 6 uit myNumber %= 6;
Om een getal te verhogen met 1, kun je schrijven myNumber = myNumber + 1 of myNumber += 1, maar er is een nog kortere schrijfwijze: myNumber++. (Heb ik die ++ niet eerder gezien?) En als je een getal wilt verlagen met 1: myNumber--.
Om te rekenen met gebroken getallen maak je gebruik van het type float. Het rekenen met gebroken getallen gaat net zo als het rekenen met gehele getallen, alleen bij gebroken getallen kun je geen gebruiken maken van de %.
Het komt nogal eens voor dat je expressies erg lang worden. In zo'n geval is het niet altijd direct duidelijk wat een expressies als uitkomst heeft. Bijvoorbeeld: 4 * 5 + 6 % 4 - 7. Gebruik in zo'n geval haakjes om duidelijk te maken wat je bedoelt. 4 * (5 + 6) % (4 - 7) geeft een heel ander resultaat dan (4 * 5) + (6 % (4 - 7)).