C++
Naslagwerkje en klein
overzicht
Van de eigenschappen
ãLaurent Koen
Index
Hoe onstaat een
C++ programma?
Waaruit bestaat
een C++ programma?
Een eerste
eenvoudig c ++ programma
Een woordje over
de preprocessor compiler en linker
Locale variabelen
(automatische variabelen)
Prioriteitstabel
van de operatoren
Functies die wel
een waarde afleveren
Hoe kan je op een
eenvoudige manier een array vullen?
Overzicht meest belangrijkste C++ kenmerken
C++ is eigenlijk een aanpassing van c, hieraan zijn uitbreidingen en verbeteringen aan toegevoegd. Via c++ heeft c als het ware een facelift ondergaan en is de taal aan een tweede jeugd begonnen.
Met c++ is objectgeoriënteerde programmeren mogelijk. Dat wil onder andere zeggen dat je in c++-objecten kunt definiëren. Wat is precies een object? Hierover bestaat veel verwarring en het blijkt moeilijk te zijn dit in een paar zinnen uit te leggen. Je kunt een object vergelijken met een plastieken bekertje. Aanvankelijk is het leeg maar je kan er van alles in stoppen. Als programmeur beslis je wat je erin stopt: stukjes tekst zoals een naam of een adres, of een getal zoals een maandsalaris. Ook procedures kun je in een object stoppen, zoals een procedure die om de naam vraagt, of die de hoogte van het salaris op papier afdrukt. Het komt er op neer dat je alle gegevens en alle procedures waarvan je vindt dat die iets met elkaar te maken hebben, in 1 object plaatsen.
Omdat objecten ook procedures kunnen bevatten kun je zeggen dat object-gericht programmeren in zekere zin procedureel-gericht programmeren omvat. Anders geformuleerd: zoals c++ een fundamentele uitbreiding van c betekent, zo is het object-georienteerd programmeren een fundamentele uitbreiding van procedureel programmeren. Zo’n fundamentele uitbreiding vraagt uiteindelijk wel om een andere aanpak bij het schrijven van een programma. Dat neemt niet weg dat procedureel programmeren vaak een wezenlijk bestanddeel vormt van het object gericht programmeren.
1. Eerst moet je een programma schrijven in een editor.
2. Daarna worden de “preprocessor”-directives opgezocht en ingevoegd op de plaats waar deze staan. Een “preprocessor”-directive is te herkennen aan het # dat ervoor staat.
3. Gaat de compiler na of er “syntax” fouten aanwezig zijn in het programma, en dan wordt het programma vertaald naar de machinecode.
4. Als laatste wordt het programma gelinkt, dit wil zeggen dat gebruikte functies uit bibbliotheken worden opgehaald en een kopij van de definitie ervan in het programma wordt opgenomen.
1. Een c++ programma heeft altijd minstens 1 functie, namelijk main(), deze is meestal van het type void, deze kan echter ook een andere vorm aannemen main( int *argv,char **argc[]).
2. De functie main, en alle functies zijn ingesloten in { en }.
3. Daarbij komt dat er ook altijd minstens 1 “preprocessor”-directive zal zijn, vb #include “stdio.h”
Code in c
#include
<stdio.h>
#include
<conio.h>
void main()
{int getal1,getal2,getal3;
getal1=getal2=getal3=0;
printf(" Berekenen van twxee getallen\n");
printf("Geef het eerste getal in : \t");
scanf("%d",&getal1);
printf("Geef het eerste getal in : \t");
scanf("%d",&getal2);
printf(" uitkomst = %d",getal3=getal1+getal2);
getch();
}
Code in c++
// Voorbeeld 1.1
#include
<iostream.h>
void main()
{int getal1,getal2,getal3;
cout << "Twee getallen bij elkaar opgeteld: ";
cout << "Eerste getal = ";
cin >> getal1;
cout << "Tweede getal = ";
cin >> getal2;
getal3 = getal1+getal2;
cout << "Uitkomst van " << getal1 << " + " << getal2 << " = " << getal3;
cin >> getal1;
cin.get();
}
C++ werkt eigenlijk met 2 schermen.
Het eerste scherm is het scherm van de editor, hier typ je je programma in. Het tweede scherm is het scherm waar de resultaten, de zogenaamde uitvoer, van je programma in komt. Het eerste scherm zullen we voor het gemak editor noemen en het tweede scherm zullen we uitvoerscherm noemen.
Elk c++ programma dat je intikt moet eerst worden vertaald voor het kan worden uitgevoerd. Het hele vertaalprocess verloopt in fasen. Hierin komen achtereenvolgens de volgende onderdelen voor.
- preprocessor
- compiler
- linker
C++ compiler en linker
De preprocessor leest je c++ programma en gaat al lezend op zoek naar preprocessor opdrachten, de zogenaamde preprocessor directives Een preprocessor directive kun je herkennen aan het hekje # dat er voor staat.
Zo is # include <iostream.h> een preprocessor directive
De betekenis van deze opdracht is dat de preprocessor op zoek gaat naar een bestand op schijf dat iostream.h heet (het bestand is een onderdeel van c++). De complete inhoud van dit bestand moet dan door de preprocessor worden ingevoegd (ge-include) op de regel waar het voorkomt.
We gaan nu niet te uitgebreid in op het waarom van het invoegen van iostream.h, maar volstaan met de opmerking dat de inhoud van het bestand iostream.h informatie bevat die de compiler nodig heeft om ons c++ programma goed te vertalen
Inhoud van iostream.h + Ons c++ programma = Hier komt de inhoud van iostream.h Ons c++ programma
Na de preprocessor is het de beurt aan de compiler om het c++ programma te lezen. De compiler heeft 2 belangrijke taken:
- Het programma controleren op fouten, en daar melding van maken.
- Als er geen fouten zijn het programma vertalen naar machinetaal.
Laten we even aannemen dat het programma taalkundig correct is, zodat er een vertaling tot stand komt. De vertaling wordt op de schijf gezet, in een bestand waarvan de naam het achtervoegsel.obj heeft.
Vertaalde versie van ons programma in
machinecode op schijf Hier komt de inhoud van iostream.h Ons c++ programma
De
c++ compiler maakt de vertaling
De rol van de compiler is nu uitgespeeld Vervolgens komt de linker aan de beurt
C++ wordt geleverd met honderden voorgedefinieerde functies, klaar voor het gebruik. Deze functies zitten opgeborgen in bestanden op schijf die ‘libraries’ heten. Het woord library betekent letterlijk bibliotheek, maar het is duidelijk dat het hier niet om boeken gaat. De overeenkomst met een echte bibliotheek is dat er een voorrad functies is (in plaats van boeken), waar elk c++ programma naar believen kopieën van kan maken.
Een belangrijke taak van de linker is om een kopie van de functies die het vertaalde c++ programma nodig heeft, uit de bibliotheek te halen en deze toe te voegen aan het c++ programma. Het resultaat daarvan wordt weggeschreven nar een nieuw bestand op de schijf, met het achtervoegsel.exe. Het .exe bestand is het bestand waar het allemaal om draait: Daar zitten in machinetaal alle opdrachten en alle informatie in die de pc nodig heeft om het uit te voeren wat je oorspronkelijk bedoelde toen je het c++ programma intikte.
Programma.exe
Programmanaam.obj Iostream.h + cpp programma
libraries
C++ compiler maakt
vertaling linker
Dit is de gang van zaken als de compiler geen fouten gevonden heeft. Wat gebeurt er als dat wel het geval is? Er verschijnen dan een of meer meldingen over fouten, zogenaamde foutmeldingen (errores of error messages), en soms verschijnen er ook waarschuwingen (warnings). De meeste compilers zetten voor elke foutmelding en waarschuwing een nummer, dat verwijst naar het nummer van de regel waar de fout is geconstateerd. In die regels moet je dus gaan zoeken naar eventuele fouten. Het is daarbij belangrijk te beseffen dat de compiler achteraf op foute reageert: het is soms zo dat de echte fout vb op regel 12 staat en dat de compiler zegt dat de fout op regel 13 gemaakt is. Het vinden van fouten en het verbeteren daarvan kan vooral in het begin nogal lastig zijn. Je zondigt immers tegen de regels van een taal die je nog niet goed kent.
Zodra je de fouten verbetert hebt geef je opnieuw opdracht om het programma te laten runnen (= laten vertalen en laten uitvoeren), in de hoop dat het nu veel beter gaat. Als dat niet zo is, dan zit er niets anders op dan opnieuw een verbetering aan te brengen.
Wordt gebruikt om uitvoer naar het scherm te sturen, deze worden ook wel streams genoemd.
Gebruik : cout << “mijn tekst” << endl;
Merk op het gebruik van <<, endl wordt gebruikt om een nieuwe lijn te beginnen. \n \t kunnen nog steeds gebruikt worden.
Zo kan je ook een bewerking in je cout zetten vb :
cout << "ok = " << ok << " som van de getallen is " << (getal + getal2) <<endl;
cin.get() Deze functie wacht op een enter. Dit wordt gebruikt om het outputscherm even te laten staan zodat je de resultaten kan lezen.
Cin : Om gegevens in een variabele op te slaan, je zal ook zien dat de stream anders loopt nl >>
Van input naar variabele. Om strings in te lezen wordt cin.getline(var,lengte); gebruikt
<< wordt de insertion-operator genoemd.
>> wordt de extraction-operator genoemd.
|
Category |
Type |
Contents |
|
Integral |
char |
Type char is
an integral type that usually contains members of the execution character set
— in Microsoft C++, this is ASCII. |
|
|
|
The C++ compiler
treats variables of type char, signed char, and unsigned
char as having different types. Variables of type char are
promoted to int as if they are type signed char by
default, unless the /J compilation option is used. In this case they are
treated as type unsigned char and are promoted to int
without sign extension. |
|
|
short |
Type short int
(or simply short) is an integral type that is larger than or equal to
the size of type char, and shorter than or equal to the size of type int. |
|
|
|
Objects of type short
can be declared as signed short or unsigned short. Signed
short is a synonym for short. |
|
|
int |
Type int is
an integral type that is larger than or equal to the size of type short
int, and shorter than or equal to the size of type long. |
|
|
|
Objects of type int
can be declared as signed int or unsigned int. Signed
int is a synonym for int. |
|
|
__intn |
Sized integer, where
n is the size, in bits, of the integer variable. The value of n
can be 8, 16, 32, or 64. |
|
|
long |
Type long (or
long int) is an integral type that is larger than or equal to
the size of type int. |
|
|
|
Objects of type long
can be declared as signed long or unsigned long. Signed
long is a synonym for long. |
|
Floating |
float |
Type float is
the smallest floating type. |
|
|
double |
Type double
is a floating type that is larger than or equal to type float, but
shorter than or equal to the size of type long double.1 |
|
|
long double1 |
Type long double
is a floating type that is equal to type double. |
1 The representation of long
double and double is identical. However, long double and double
are separate types.
Microsoft Specific
Table 2.4 lists the
amount of storage required for fundamental types in Microsoft C++.
Table
2.4 Sizes of Fundamental Types
|
Type |
Size |
|
char, unsigned char, signed char |
1 byte |
|
short, unsigned short |
2 bytes |
|
int, unsigned int |
4 bytes |
|
long, unsigned long |
4 bytes |
|
float |
4 bytes |
|
double |
8 bytes |
|
long double1 |
8 bytes |
1 The
representation of long double and double is identical. However, long
double and double are separate types.
For more information
about type conversion, see Chapter 3, Standard Conversions.
END Microsoft Specific
|
Category |
Type |
Bereik |
|
Integral |
char |
- 128 -> 127 |
|
|
Unsigned char |
0..255 |
|
|
short |
0..65535 |
|
|
Signed short |
-32768..32767 |
|
|
int |
-2147483646..2147483647 (ook wel -32768..32767) |
|
|
Unsigned int |
4294967295 (ook wel 65535) |
|
|
long |
-2147483646..2147483647 |
|
|
|
|
|
Floating |
Float min |
1.175494351e-38 |
|
|
Float max |
3.402823466e+38 |
|
|
Double
min |
2.2250738585072014e-308 |
|
|
Double
max |
1.797693148623158e+308 |
|
|
long double min |
3.4e-4932 |
|
|
long double max |
1.1e+4932 |
Eerst komt het type, daarna de naam van de variabele.
Deze naam mag niet beginnen met een cijfer, mag geen spaties bevatten, er mag geen apostrof in
voorkomen, geen & en geen operatoren.
C++ maakt onderscheid tussen grote en kleine letters. De naam mag zolang
zijn als je wil, maar de compiler gaat enkel de eerste 32 karakters
onderscheiden.
Deze worden voor de functie main geplaatst. Zij zijn gekend gedurende de uitvoering van het programma.
Deze worden binnen een functie gedeclareerd, en de levensduur is per definitie beperkt tot de functie zelf, er zijn wel manieren om dit te omzeilen, daarover later meer.
Vb
void main()
{ int
nGetal;
double dGetal ;
long lGetal ;
float fGetal ;
char cLetter;
}
In C en C++ kan je een bepaalde variabele een constante waarde geven, dit kan handig zijn als een verwerking moet gebeuren in het programma die steeds dezelfde berekeningen moet uitvoeren.
Vb
Const
double pi = 3.14;
Ander type is de define
#define pi 3.14;
Wat is nu het grote verschil tussen deze twee type declaraties?
#define is een preprocessor directive, wat wil zeggen dat overal waar de naam van de variabele staat, deze wordt vervangen door de waarde van de variabele. Merk ook op dat hier geen = teken wordt gebruikt om de waarde toe te kennen.
Const, de waarde wordt pas ingevuld als deze nodig is in het programma.
Automatische conversie In sommige gevallen zal het nodig zijn om variabelen van een verschillend type met elkaar op te tellen. Stel, je hebt 2 ints en een double.
Int 1 = 12
Int 2 = 15
Double
=2.35689
Uitkomst zal 29.35689 zijn. De conversie gaat altijd van laag naar hoog
Soms gebeurt er ook geen automatische conversie, deze kan je dan gaan forceren met een “cast”. Dit betekent eigenlijk iets in een andere vorm gieten. Dit is zeker handig bij delingen, als je twee ints zou delen, krijg je altijd een geheel getal, met de cast kan je er toch voor zorgen dat het een restdeling is.
Double(var1)/var2; geeft een double.
Float();
Operator |
Operatie |
|
> |
Groter dan |
|
< |
Kleiner dan |
|
>= |
Groter dan of gelijk aan |
|
<= |
Kleiner dan of gelijk aan |
|
== |
Is gelijk aan |
|
!= |
Niet gelijk aan (verschillend van) |
|
Operand 1 |
Operand
2 |
Resultaat
|
|
|
0 |
0 |
0 |
|
|
0 |
1 |
0 |
|
|
1 |
0 |
0 |
|
|
1 |
1 |
1 |
|
De waarden 0 worden als niet waar beschouwd
|
Operand 1 |
Operand 2 |
Resultaat |
|
0 |
0 |
0 |
|
0 |
1 |
1 |
|
1 |
0 |
1 |
|
1 |
1 |
1 |
For(int
i;i<10;i++)
{
blabla;
}
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
|
|
|||
Indien er meerdere statements zijn Indien er maar 1 statement per if is
if
(statement)
{
statement;
}
else
{
statement;
}
if
(statement)
statement;
else
statement;
if
(statement)
{
statement;
}
while
(statement)
{
statement;
…
}
do
{
statement;
…
}while(statement)
grote verschil is dat een do while loop altijd 1* meer zijn lus gaat doorlopen.
Break : om uit een loop te springen.
Continue je springt uit de loop , maar de loop wordt niet verlaten, je gaat de test doen.
Wordt gebruikt om meerdere mogelijkheden af te testen van een bepaald gegeven.
Switch(voorwaarde)
{
case 1: statement
break; -> dit moet er altijd staan, anders wordt de test voor alles gedaan, wat wil zeggen dat je eigenlijk teveel test gaat doen, dat is echter overbodig.
default : j
}
Functies zijn heel belangrijk in de wereld van programmeren, zij zorgen ervoor dat stukjes code die in een programma meerdere malen gebruikt kunnen worde slechts 1* geschreven moeten worden, hierdoor zal de leesbaarheid van het programma aanzienlijk toenemen.
Eigenlijk wordt dit niet declareren genoemd, maar function prototyping.
Wat wil dit nu eigenlijk in woorden zeggen?
Voor de goede werking, verwacht de compiler dat er voor elke functie die je gebruikt een soort basisvorm in het begin van het programma, dus voor de functie main, wordt geplaatst.
Vb
#include
“iostream.h”
void getal(int nGetal,double dGetal); // voor een functie met variabelen
Wat kunnen we hier zien, deze functie zal geen waarden teruggeven, want ze is van het type void.
Aanroep van deze functie vb getal(2,2.5);
De functie zelf kan er vb als volgt uitzien
Void getal(int nGetal,double dGetal)
{
sqrt(nGetal,dGetal);
}
1. Zorg ervoor dat de naam van de functie zo nauw mogelijk aansluit bij wat de functie doet, vb als je een functie schrijft die een dfeling doet, noem je die best deling en niet mijn_functie.
2. Schrijf functies zodanig dat je ze eventueel kan hergebruiken, vb schrijf een functie voor een deling zodanig dat je een willekeurig aantal waardes kan meegeven om te delen, vb van een slechte functie
Void deling(int getal1)
{ getal1/2;
}
deze functie kan enkel delen door 2 en er is geen return.
Double deling (int getal1, int getal2)
{double getal3=0;
getal3= (getal1/getal2);
return getal3;
}
Dit is beter, hier kan een getal gedeeld worden door verschillende waarden.
· Eigenlijk is dat niet zo belangrijk, aangezien in C++ de functies bovenaan gedeclareerd worden weet de compiler waar deze functies staan.
· Wel kan je ervoor zorgen dat de functies,worden geschreven, vb in de volgorde van aanroep of alfabetisch.
· In C++ is prototyping niet echt nodig , in die zin, als je de functie plaatst voor ze wordt opgeroepen, wordt dit aanzien als de prototyping. Let wel op, dat deze manier van werking eigenlijk niet echt goed en overzochtelijk wordt, je zal wel snel ondervinden dat als je grotere programma’s maakt, deze manier van werking voor veel problemen zal zorgen.
Je kan ook default waarden aan een variabele geven, deze wordt gebruikt in het geval er geen waarde wordt meegegeven, deze waarde moeten steeds achteraan de declaratie staan.
Prototyping van de functie is vb void delen(int getal1, int getal2);
De functie zelf ziet er vb als volgt uit :
Void delen(int getal1, int getal2=2)
{
getal1/getal2;
}
als er wel een waarde meegeeft vb delen(15,10), wordt de defaultwaarde genegeerd.
Het is natuurlijk veel handiger als je een functie kan schrijven die je wel een waarde afleverd waarmee je verder kan rekenen in het programma.
Prototyping van zulk een functie
double deling( int getal1, int getal2);
de functie zelf
double deling(int getal1, int getal2)
{double getal3=0;
getal3= (getal1/getal2);
return getal3;
}
de oproep van deze functie in vb main is dan als volgt
getal5=deling(getal1,getal2);
Blijven hun waarde behouden van het begin tot het einde van het programma. Ze worden maar 1 maal aangemaakt, bij de eerste aanroep.
Voordeel?
Ze behouden hun waarde gedurende het gehele programma, dit kan handig zijn als je een berekening moet maken, daarna iets anders doen, en dan terug de functie aan te roepen waar je gaat verder werken met die variabele.
Initialisatie ?
Zet het woord static voor de naam van je variabele.
Static variabelen worden altijd met 0 geïnitialiseerd, tenzij je er een andere waarde aan geeft.
Het is niet omdat deze variabelen hun waarde blijven behouden dat ze in heel je programma te zien zullen zijn, de levensduur van de waarde is ook beperkt tot de functie waar ze in gedeclareerd zijn.
Naast static variabelen, die gedurende het ganse programma hun waarde behouden, hebben we ook globale variabelen. Deze worden ook wel externe variabelen genoemd, maar we gaan ze globale variabelen noemen.
Globale variabelen worden meestal aan het begin van het programma geplaatst, na de prototyping van de functies, maar vóór de functies
Grote verschil tussen globale en statische variabelen. Globale variabelen kunnen door het ganse programma door iedere functie worden gebruikt. Statische variabelen kunnen enkel worden gebruikt in de functie waar ze in gedefinieerd zijn
,
Het is nu niet de bedoeling om al de variabelen globaal te definiëren, maar enkel in bepaalde situaties zal dit handig zijn.
Opmerking : Locale en globale variabelen die dezelfde naam hebben, zullen niet conflicteren, in die zin,een locale variabele gaat voor op de globale variabele met dezelfde naam.
Met een reference argument kan je niet alleen de waarde meegeven maar ook de variabele zelf. Dit wordt gebruikt om lokale variabelen toch een andere waarde te laten krijgen vb p127 illustreert dit duidelijk.
Een referentie variabele wordt door een ampersand voorafgegaan vb int & voorbeeld)
Referentie argumenten zijn dus read en write
Deze variabelen behouden hun waarde, je kan ze doorgeven er iets mee doen,maar de initiële waarde van de variabele blijft ongewijzigd.
Hiermee wordt bedoeld dat er een referentie van een waarde wordt afgeleverd
Een variabele kan aan de linkerkant van de assignment staan, een waarde niet!
Dit wil dus zeggen dat een functieaanroep , van een functie die een referentie aflevertd, aan de linkerkant van de aasignment mag staan
Zie vb p133
Hier wordt een echte waarde afgeleverd
Wil eigenlijk zeggen dat je een functie, met dezelfde naam, meerdere malen gaat definiëren, maar met telkens een verschillend aantal argumenten. Of een ander type van variabelen.
Zo kan je vb ook van in de ene functie de andere aanroepen.
Zie opgave5.4
Een array is eigenlijk een variabele waarin je meerdere waarden van hetzelfde type in kan plaatsen.
Je zal je misschien wel afvragen, hoe werkt dit nu eigenlijk?
Wel eigenlijk elke variabele die je aanmaakt, krijgt een adres in het geheugen, zoals we eerder gezien hebben, kan je dat adres opvragen door voor de variabele & te plaatsen.
Een arrays is eigenlijk niets meer dan een verzameling van pointers naar adressen in het geheugen.
Een array begint ALTIJD vanaf 0!!!!!
Vb
|
index |
aArray |
Naam element |
|
0 |
|
aArray[0] |
|
1 |
|
aArray[1] |
|
2 |
|
aArray[2] |
|
3 |
|
aArray[3] |
|
4 |
|
aArray[4] |
Declaratie
:
Int aArray[5];
Dit wil zeggen dat er een array van 5 elementen wordt aangemaakt.
Dus wil dit zeggen dat de bovengrens 4 is, wat gebeurd er nu als je bovengrens 5 zou nemen? Wel eigenlijk niets, in die zin, je zal geen directe fout krijgen, het enige wat er zal gebeuren is dat element 5 naar ergens in het geheugen wijst, waar dat is ??????? Het zou dus wel eens kunnen dat de plaats waar element 5 naar wijst reeds bezet is door een andere waarde (vb iets van het besturingssysteem) waardoor het wel eens kan zijn dat je computer heeel raar doet en evt je computer zal vastlopen.
Wel met een for-loop
Int
aArray[5];
For(int i =
0;i<5;i++)
{
cout << “Geef een waarde in voor getal “ << I ;
cin >> aArray[i];
}
