C++ klassen en objecten

In deze zelfstudie leren we over objecten en klassen en hoe ze te gebruiken in C++ met behulp van voorbeelden.

In eerdere tutorials hebben we geleerd over functies en variabelen. Soms is het wenselijk om gerelateerde functies en gegevens op één plek te plaatsen, zodat het logisch en gemakkelijker is om mee te werken.

Stel dat we de lengte, breedte en hoogte van een rechthoekige kamer moeten opslaan en de oppervlakte en het volume moeten berekenen.

Om deze taak uit te voeren, kunnen we drie variabelen maken, bijvoorbeeld lengte , breedte , en hoogte samen met de functies calculateArea() en calculateVolume() .

In C++ kunnen we echter, in plaats van afzonderlijke variabelen en functies te maken, deze gerelateerde gegevens en functies ook op één plaats inpakken (door objecten te maken ). Dit programmeerparadigma staat bekend als objectgeoriënteerd programmeren.

Maar voordat we objecten kunnen maken en gebruik ze in C++, we moeten eerst leren over klassen .

C++-klasse

Een klasse is een blauwdruk voor het object.

We kunnen een klas zien als een schets (prototype) van een huis. Hierin staan ​​alle details over de vloeren, deuren, ramen etc. Op basis van deze beschrijvingen bouwen wij het huis. Huis is het object.

Een klas maken

Een klasse wordt gedefinieerd in C++ met het trefwoord class gevolgd door de naam van de klas.

De hoofdtekst van de klasse wordt gedefinieerd tussen de accolades en eindigt met een puntkomma aan het einde.

class className {
   // some data
   // some functions
};

Bijvoorbeeld,

class Room {
    public:
        double length;
        double breadth;
        double height;   

        double calculateArea(){   
            return length * breadth;
        }

        double calculateVolume(){   
            return length * breadth * height;
        }

};

Hier hebben we een klasse gedefinieerd met de naam Room .

De variabelen lengte , breedte , en hoogte gedeclareerd binnen de klasse staan ​​bekend als gegevensleden . En de functies calculateArea() en calculateVolume() staan ​​bekend als ledenfuncties van een klas.

C++-objecten

Wanneer een klasse is gedefinieerd, wordt alleen de specificatie voor het object gedefinieerd; er is geen geheugen of opslag toegewezen.

Om de gegevens- en toegangsfuncties te gebruiken die in de klasse zijn gedefinieerd, moeten we objecten maken.

Syntaxis om object in C++ te definiëren

className objectVariableName;

We kunnen objecten maken van Room class (gedefinieerd in het bovenstaande voorbeeld) als volgt:

// sample function
void sampleFunction() {
    // create objects
    Room room1, room2;
}

int main(){
    // create objects 
    Room room3, room4;
}

Hier, twee objecten room1 en kamer2 van de Room klasse zijn gemaakt in sampleFunction() . Evenzo zijn de objecten room3 en kamer4 zijn gemaakt in main() .

Zoals we kunnen zien, kunnen we objecten van een klasse maken in elke functie van het programma. We kunnen ook objecten van een klasse maken binnen de klasse zelf, of in andere klassen.

We kunnen ook zoveel objecten maken als we willen van een enkele klasse.

C++ Access Data Leden en Leden Functies

We hebben toegang tot de gegevensleden en lidfuncties van een klasse met behulp van een . (punt) operator. Bijvoorbeeld,

room2.calculateArea();

Dit roept de calculateArea() . op functie binnen de Room klasse voor object room2 .

Op dezelfde manier zijn de gegevensleden toegankelijk als:

room1.length = 5.5;

In dit geval initialiseert het de lengte variabele van kamer1 tot 5.5 .

Voorbeeld 1:Object en klasse in C++-programmering

// Program to illustrate the working of
// objects and class in C++ Programming

#include <iostream>
using namespace std;

// create a class
class Room {

   public:
    double length;
    double breadth;
    double height;

    double calculateArea() {
        return length * breadth;
    }

    double calculateVolume() {
        return length * breadth * height;
    }
};

int main() {

    // create object of Room class
    Room room1;

    // assign values to data members
    room1.length = 42.5;
    room1.breadth = 30.8;
    room1.height = 19.2;

    // calculate and display the area and volume of the room
    cout << "Area of Room =  " << room1.calculateArea() << endl;
    cout << "Volume of Room =  " << room1.calculateVolume() << endl;

    return 0;
}

Uitvoer

Area of Room =  1309
Volume of Room =  25132.8

In dit programma hebben we de Room . gebruikt klasse en zijn object room1 om de oppervlakte en het volume van een kamer te berekenen.

In main() , hebben we de waarden van length . toegewezen , breedte , en hoogte met de code:

room1.length = 42.5;
room1.breadth = 30.8;
room1.height = 19.2;

We noemden toen de functies calculateArea() en calculateVolume() om de nodige berekeningen uit te voeren.

Let op het gebruik van het trefwoord public op het programma. Dit betekent dat de leden openbaar zijn en overal vanuit het programma toegankelijk zijn.

Volgens onze behoeften kunnen we ook privéleden maken met behulp van de private trefwoord. De privéleden van een klas zijn alleen toegankelijk vanuit de klas. Bijvoorbeeld,

class Test {

private:
    int a;
    void function1() { }

public:
    int b;
    void function2() { }
}

Hier, een en function1() zijn privé. Ze zijn dus niet toegankelijk van buiten de klas.

Aan de andere kant, b en function2() zijn overal in het programma toegankelijk.

Bezoek onze C++ Class Access Modifiers-tutorial voor meer informatie over openbare en privé-zoekwoorden.

Voorbeeld 2:Openbaar en privé gebruiken in C++ Class

// Program to illustrate the working of
// public and private in C++ Class

#include <iostream>
using namespace std;

class Room {

   private:
    double length;
    double breadth;
    double height;

   public:

    // function to initialize private variables
    void initData(double len, double brth, double hgt) {
        length = len;
        breadth = brth;
        height = hgt;
    }

    double calculateArea() {
        return length * breadth;
    }

    double calculateVolume() {
        return length * breadth * height;
    }
};

int main() {

    // create object of Room class
    Room room1;

    // pass the values of private variables as arguments
    room1.initData(42.5, 30.8, 19.2);

    cout << "Area of Room =  " << room1.calculateArea() << endl;
    cout << "Volume of Room =  " << room1.calculateVolume() << endl;

    return 0;
}

Uitvoer

Area of Room =  1309
Volume of Room =  25132.8

Het bovenstaande voorbeeld is bijna identiek aan het eerste voorbeeld, behalve dat de klassevariabelen nu privé zijn.

Aangezien de variabelen nu privé zijn, kunnen we ze niet rechtstreeks openen vanuit main() . Daarom zou het gebruik van de volgende code ongeldig zijn:

// invalid code
obj.length = 42.5;
obj.breadth = 30.8;
obj.height = 19.2;

In plaats daarvan gebruiken we de openbare functie initData() om de privévariabelen te initialiseren via de functieparameters double len , double brth , en double hgt .

Ga naar deze onderwerpen voor meer informatie over objecten en klassen:

• C++-constructeurs
• Hoe een object van een functie doorgeven en retourneren?