Ik zal het deze keer hebben over public, private, protected, static, virtual, signed en unsigned en wat deze allemaal betekenen in C++. Ze zijn zeker iets dat je nodig hebt in je verdere reis in C++!

Hoewel je ze voornamelijk terug ziet in classes kom je ze ook wel tegen op andere plaatsen. Ik zal ze behandelen vanuit het perspectief van de classes. Artikelen die op dit volgen zullen dan ook over de classes gaan. Dit artikel is onderdeel van de categorie "classes" in het C++ overzicht en dus is het goed mogelijk dat er andere artikelen verschijnen die bij de vorige categorie terecht komt of bij de volgende categorieën. Het simpelweg kopiëren en plakken van de codes zal logischer wijze errors opleveren. Omdat zoals altijd in de comments achter dergelijke regels is verteld dat deze fout zijn. Het is dan ook puur om een visuele weergave te geven.

Uit "CScript.h" in de source van V:Online. Door: @Megadreams

Public

Het woord zegt het hem zelf, public oftewel publiek. De functie/variabele is rechtstreeks aan te roepen vanuit een andere class. Meer valt er eigenlijk niet te zeggen van "public".

Ik zal het even laten zien doormiddel van kleine voorbeelden:

#include <iostream>

using namespace std;

class voorbeeldClass
{
public: 
	int getal;
	virtual void printHelloWorld() { cout << "Hello World\n";};
};

int main()
{
voorbeeldClass test;
test.printHelloWorld(); // Er zal ongeacht waar je het geplaatst hebt de tekst "Hello World" op jou scherm verschijnen.
test.getal = 250; // Zet het getal in de class op 250.
cout << test.getal; // Geeft 250.

cin.get();
}

Private

Namen in C++ zeggen al erg veel waarover het gaat, zo ook bij private welk in het nederlands privé betekend. Variables en classes die als private zijn gedefiniëerd kunnen enkel vanuit deze class worden aangeroepen.

Het wil natuurlijk niet betekenen dat je nooit vanuit een andere class een variable dat op private staat kan veranderen. Hiervoor zal je een public functie moeten maken in die class welke je aanroept en die de variable zal aanpassen. Protected komt vrijwel overeen met private.

Voorbeelden:

#include <iostream>

using namespace std;

class voorbeeldClass
{
private:
	int getal;
	int berekenSom(int getal1, int getal2);

public: 
	virtual void veranderGetal(int aantal) { getal = aantal; };
	virtual int leesGetal() { return getal; };
};

int main()
{
voorbeeldClass test);
test.getal = 250; // Dit zal een error geven, welke je vertelt dat deze variable ontoegankelijk is.
cout << test.berekenSom(10,20); // Dit zal ook simpelweg een error opleveren dat de functie ontoegankelijk is.
cout << test.getal; // Het getal is ook ontoegankelijk om te lezen.

test.veranderGetal(10); // Dit roept de public functie "veranderGetal" aan welke de variable getal wel kan aanpassen.
cout << test.leesGetal(); // Zal 10 teruggeven welke in de private variable getal is opgeslagen. Ook deze public functie heeft doordat hij in dezelfde class zit toegang tot de variable.

cin.get();
}

Static

We zijn aanbeland bij "static" of in het nederlands: "statisch". Normaliter als je een variable definiëert in een class zal deze telkens als je een nieuwe object maakt opnieuw gekopiëerd worden. Dit maakt het mogelijk om er bij elk object een andere waarde aan toe te kennen. Maar soms wil je dat gewoon niet en daarvoor is static.

Als je een variable of zelfs een functie (minder toepasselijk") naast public, private etc ook nog eens met static definiëert zal deze voor elk object exact hetzelfde zijn. De variable zal ongeacht door welk object het gewijzigd wordt ook voor de andere gewijzigd zijn.

Een static functie is al iets ingewikkelder, deze hebben ten eerste geen toegang tot "this->" welk object afhankelijk is. Je gebruikt een static functie vooral wanneer je een functie in de class wil hebben welke geen initialisatie van deze class nodig heeft, dit kan ook bij een static variable.

Voorbeelden:

#include <iostream>

using namespace std;

class voorbeeldClass
{
public:
	int getal1;
	static int getal2;
	void test();
	static void test2();
};

int main()
{
voorbeeldClass test1;
voorbeeldClass test2;

test1.getal1 = 10;
test2.getal1 = 20;

cout << test1.getal1; // Geeft "10".
cout << test2.getal1; // Geeft "20".

test1.getal2 = 50;
test2.getal2 = 100;

cout << test1.getal2; // Geeft "100".
cout << test2.getal2; // Geeft "100".

voorbeeldClass::test(); // Geeft een error.
voorbeeldClass::test2(); // Werkt

cin.get();
}

Virtual

Virtual of in het nederlands virtueel gebruik je om een virtuele functie te maken in de header file. Een normale gedefiniêerde functie zal enkel zorgen voor de verwijzing naar deze functie in de source file. Een virtuele functie daarentegen is enkel te vinden in de header en zit zelfs al meteen in de definitie in de header. Dit is best enkel te gebruiken voor 1 regel functies. Om een bepaald getal op te halen of iets kleins uit te rekenen.

Virtuele functies zijn natuurlijk ook maar enkel in staat om te werken met variables in de header file en niet met deze in de source file.

Voorbeelden:

// Test.h

#include <iostream>

using namespace std;

class voorbeeldClass
{
public: 
	int berekenSom(int getal1, int getal2); // Heeft een achterliggend script in "test.cpp".
	virtual int berekenVerschil(int getal1, int getal2) { return (getal1-getal2); }; // Het script zit al in "test.h".
};

// Test.cpp

#include "test.h"

int voorbeeldClass::berekenSom(int getal1, int getal2) // De achterliggende functie voor de definitie in test.h.
{
return (getal2+getal2);
}

int main()
{
voorbeeldClass test;
cout << test.berekenSom(10,20); // Geeft 30.
cout << test.berekenVerschil(20,10); // Geeft 10.

cin.get();
}

Signed & Unsigned

Ik heb deze even samen genomen omdat er een korte uitleg achter zit en omdat ik het anders toch twee keer zo goed als hetzelfde uitleg. Ten eerste signed & unsigned worden enkel gebruikt bij variables met een type dat een getal representeerd. Ik zal in deze uitleg me enkel houden bij integers. Een integer bestaat op 32 & 64 bits computer uit 32 bits. De laatste bit (Meest Significante Bit of MSB) geeft weer of het getal negatief of positief is. Signed wat je eigenlijk nooit typt doordat elke variable standaard al signed is geeft weer dat het getal zowel negatief als positief kan zijn. Unsigned daarentegen kan enkel een positief getal zijn en ook 0.

Wat is nu het grote voordeel van signed & unsigned? Als je zeker weet dat een getal nooit onder de 0 zal gaan dan heb je een voordeel als je signed gebruikt. Je zal namelijk die laatste bit "openstellen" voor het getal zelf. Een signed integer gaat van −2.147.483.648 tot 2.147.483.647. Je ziet dat je aan de negatieve kant met 1 hoger zit dan aan de positieve kant. Dit simpelweg omdat 0 al bij de positieve kant is bij gerekend. Een unsigned integer gaat van 0 tot 4.294.967.295. Als je dus enkel met een positief getal te maken hebt kan je zo het bereik aan de positieve kant maar liefst verdubbelen!

Voorbeelden:

#include <iostream>

using namespace std;

int main()
{
signed int getal1; // Hetzelfde als: "int getal1;"
unsigned int getal2;

getal1 = 2147483647;
cout << getal1; // Geeft netjes "2147483647" het totale maximum van een signed integer.
getal1+1;
cout << getal1; // Een overflow, resulteert in het verder gaan aan de negatiave kant. Uitkomst is normaliter: "−2147483648". Maar je zal eerder een error krijgen.

getal2 = 2147483650;
cout << getal2; // Geeft netjes "2147483650", een unsigned heeft aan de positieve kant namelijk een dubbel bereik.
}

Dit was het dan voor deze keer, in het volgende artikel kan je lezen over de classes en hoe ze te maken.