C++ Classes & Objects: Praktische Handleiding met Code‑Voorbeelden

Wat is een Class?

Een C++ class is een user‑defined datatype die data en de functies die op die data opereren, in één entiteit bundelt. Zie het als een blauwdruk: het definieert de vorm en het gedrag van objecten die ervan gecreëerd kunnen worden.

Net zoals een huis‑blauwdruk de plaatsing van deuren, vensters en kamers specificeert, beschrijft een class de indeling van zijn data‑members en de operaties die ze kunnen manipuleren. Meerdere huizen (objecten) kunnen gebouwd worden vanuit dezelfde blauwdruk.

In de illustratie bovenaan produceert het ene prototype twee verschillende huizen met verschillende kenmerken.

In deze tutorial leer je:

• Wat een class is en waarom het in C++ belangrijk is
• Concrete class‑voorbeelden
• De rol van private en public access modifiers
• Hoe objecten te creëren (instantiatie)
• Data members veilig benaderen
• Member functies binnen en buiten de class definitie
• Constructors en destructors in actie

Class Declaratie

Een class declareren is eenvoudig: gebruik het class-keyword gevolgd door de classnaam en omsluit de body met accolades.

Syntaxis

class className { // data members // member functions }; 

• className – de identifier voor je class.
• Data members worden typisch als variabelen gedeclareerd.
• Member functions bieden gedrag.

Access Modifiers: private vs. public

Access modifiers controleren de zichtbaarheid van class‑leden.

• private – leden zijn alleen toegankelijk binnen de class of zijn friends.
• public – leden kunnen benaderd worden vanuit elke context waar het object zichtbaar is.

Objecten Creëren (Instantiatie)

Objecten zijn instanties van een class. Het declareren van een object volgt hetzelfde patroon als een variabele declareren: className objectName;

Syntaxis

className objectName; 

• className – de class waaruit het object gecreëerd wordt.
• objectName – de identifier voor het nieuwe object.

Instantiatie allokeert geheugen voor het object en kan de constructor triggern.

Data Members Benaderen

Publieke data members worden benaderd met de punt‑operator (.).

Voorbeeld

#include <iostream>
using namespace std;
class Phone {
public:
    double cost;
    int slots;
};
int main() {
    Phone Y6;
    Phone Y7;
    Y6.cost = 100.0;
    Y6.slots = 2;
    Y7.cost = 200.0;
    Y7.slots = 2;
    cout << "Cost of Huawei Y6 : " << Y6.cost << endl;
    cout << "Cost of Huawei Y7 : " << Y7.cost << endl;
    cout << "Number of card slots for Huawei Y6 : " << Y6.slots << endl;
    cout << "Number of card slots for Huawei Y7 : " << Y7.slots << endl;
    return 0;
 } 

Output:

Waarom Getters/Setters Gebruiken?

Directe toegang of wijziging van data kan encapsulatie breken. Het gebruik van getter- en setter-member‑functies biedt gecontroleerde toegang.

Voorbeeld met Encapsulatie

#include <iostream>
using namespace std;
class ClassA {
public:
    void setA(int val);
    int getA() const;
private:
    int a;
};
int ClassA::getA() const {
    return a;
}
void ClassA::setA(int val) {
    a = val;
}
int main() {
    ClassA obj;
    obj.setA(20);
    cout << "Value of a is: " << obj.getA();
    return 0;
 } 

Output:

Protected Members en Inheritance

Protected leden zijn toegankelijk binnen de class en door afgeleide klassen, wat gecontroleerde inheritance mogelijk maakt.

Voorbeeld

#include <iostream>
using namespace std;
class ParentClass {
protected:
    int value;
};
class ChildClass : public ParentClass {
public:
    void setId(int x) {
        value = x;
    }
    void displayValue() {
        cout << "Value is: " << value << endl;
    }
};
int main() {
    ChildClass c;
    c.setId(21);
    c.displayValue();
    return 0;
 } 

Output:

Member Functies Binnen vs. Buiten de Class

Member functies kunnen inline binnen de class gedefinieerd worden of gedeclareerd binnen en later gedefinieerd met de scope resolution operator ::.

Voorbeeld

#include <iostream>
#include <string>
using namespace std;
class Guru99 {
public:
    string tutorial_name;
    int id;
    void printName();
    void printId() {
        cout << "Tutorial id is: " << id;
    }
};
void Guru99::printName() {
    cout << "Tutorial name is: " << tutorial_name;
}
int main() {
    Guru99 guru;
    guru.tutorial_name = 'C++';
    guru.id = 1001;
    guru.printName();
    cout << endl;
    guru.printId();
    return 0;
 } 

Output:

Constructors en Destructors

Constructors initialiseren objecten wanneer ze gecreëerd worden, terwijl destructors opruimen net voordat een object vernietigd wordt.

Voorbeeld

#include <iostream>
using namespace std;
class ClassA {
public:
    ClassA() {
        cout << "Class constructor called" << endl;
    }
    ~ClassA() {
        cout << "Class destructor called" << endl;
    }
};
int main() {
    ClassA a; // constructor called
    int p = 1;
    if (p) {
        ClassA b; // constructor called, destructor called at end of block
    } // destructor voor 'a' called hier
    return 0;
 } 

Output:

Belangrijkste Lessons

• C++ is fundamenteel object‑georiënteerd; classes zijn de bouwstenen.
• Een class groepeert data en gerelateerde functies, wat een herbruikbare blauwdruk creëert.
• Gebruik public, private en protected om encapsulatie af te dwingen.
• Instantieer objecten met de classnaam gevolgd door de objectnaam.
• Benader publieke leden via de punt‑operator; gebruik getters/setters voor private data.
• Member functies kunnen inline of buiten de class gedefinieerd worden met ::.
• Constructors initialiseren objecten; destructors regelen opruimen.