|
Bijvoorbeeld "stdio.h" wordt "cstdio".
Woƒe edzi q
=== Functies versus objecten ===
Een van de grootste verschillen - zoniet het grootste - tussen C en C++ is dat er objecten i.p.v. functies kunnen worden gebruikt. Het klinkt moeilijker dan het is, kijk maar...
Het C-programma "Hello World":
{{code
|Taal= C
|Titel=
|Code=
<syntaxhighlight lang=c>
#include <stdio.h>
/* Print Hello World! op het scherm */
main()
{
printf("Hello World!\n");
}
</syntaxhighlight>}}
Het C++-programma "Hello World":
{{code
|Taal= C++
|Titel=
|Code=<syntaxhighlight lang=cpp>
#include <iostream>
// Print Hello World! op het scherm.
// In C++ krijgen functies een type mee, dit is meestal void of int.
int main(void)
{
// endl staat voor end line en doet dus hetzelfde als \n.
// betekenis code: verplaats naar cout eerst "Hello World!" en daarna endl.
// cout plaatst de uitvoer vervolgens op het scherm.
std::cout << "Hello World!" << std::endl;
// dit betekent: programma afgesloten zonder problemen
return 0;
}
</syntaxhighlight>}}
Een tweede versie van het "Hello World" programma maakt gebruik van een "Begroeter"-object, een instantie van de klasse "Begroeter":
{{code
|Taal= C++
|Titel=
|Code=<syntaxhighlight lang=cpp>
// Gebruik de iostream header en de string header
#include <iostream>
#include <string>
using std::cout; // Wanneer we 'cout' of 'endl' gebruiken refereren we
using std::endl; // naar deze uit de naamruimte 'std'
using std::string;
// Definitie van de klasse "Begroeter".
class Begroeter{
private:
// Privaat toegankelijke onderdelen, enkel toegankelijk
// in de klasse zelf.
string begroeting;
public:
// Publieke toegankelijk onderdelen, van overal toegankelijk.
// Default constructor maakt een nieuwe instantie van
// deze klasse aan.
Begroeter(){
begroeting = "Hello World";
}
// De zegHallo memberfunction, deze voert de begroeting uit.
void zegHallo(){
cout << begroeting << endl;
}
};
int main(void){
// Maakt een nieuwe klasse aan en roept de default
// constructor op.
Begroeter groeter;
// Roep de lidfunctie 'zegHallo()' op.
groeter.zegHallo();
// Alles was ok, geef 0 terug.
return 0;
}
</syntaxhighlight>}}
Het Begroeter-object wordt gedefinieerd door het class- of het struct-keyword (class is nieuw tov C, en struct kan hier nu ook memberfunctions bevatten en is dus uitgebreid tegenover C). Zoals opvalt, is de klassedefinitie in twee gesplitst door de woorden "private" en "public". Na "private" komen alle lidfuncties en variabelen die eigen zijn aan de klasse en niet van buitenaf geraadpleegd of gewijzigd kunnen worden.
Voorbeelden:
*Vanuit de main functie kan men de 'begroeting' string niet wijzigen of opvragen (adhv groeter.begroeting).
*Indien de zegHallo() lidfunctie, die nu in het "public" deel staat en dus publiek toegankelijk is (adhv groeter.zegHallo() ), verplaatst zou worden naar het "private" gedeelte, zou de oproep falen.<br />
In het "private" gedeelte zit enkel de begroetingsstring (C++ ondersteunt string objecten welke makkelijker te hanteren zijn dan de char * in C, char * is wel nog steeds bruikbaar). Deze begroetingsstring wordt ingesteld door
de defaultconstructor in het publieke gedeelte van de klasse. Een constructor is een lidfunctie die geen returntype heeft en als naam, de naam van het object heeft. Deze wordt aangeroepen indien een instantie van het object aangemaakt wordt om administratieve zaken goed te zetten (in dit geval de private begroetingsstring). In een programma schrijven "klasseNaam identifier" roept de default constructor (een constructor die geen parameters neemt) impliciet aan tenzij
overladen constructors beschikbaar zijn en aangeroepen worden. Een uitbreiding op de klasse zou de volgende kunnen zijn:
{{code
|Taal= C++
|Titel=
|Code=
<syntaxhighlight lang=cpp>
class Begroeter{
....
public:
...
Begroeter(string s){
begroeting = s;
}
...
};
</syntaxhighlight>
}}
Hier definieren we een tweede constructor welke de begroeting wijzigt, wanneer we nu het
hoofdprogramma zouden wijzigen tot:
{{code
|Taal= C++
|Titel=
|Code=
<syntaxhighlight lang=cpp>
int main(void){
// Maakt een nieuwe klasse aan en roept de default
// constructor op.
Begroeter groeter("Kiekeboe");
// Roep de lidfunctie 'zegHallo()' op.
groeter.zegHallo();
// Alles was ok, geef 0 terug.
return 0;
}
</syntaxhighlight>}}
Dan roepen we de tweede constructor op die een string als argument neemt. De laatste publieke functie in de klasse is de zegHallo() lidfunctie welke de begroeting uitschrijft naar standaard uitvoer.
==Waarom C++ leren?==
| 