C ++ Inkapseling (met voorbeelden)

In deze tutorial leren we met behulp van voorbeelden over inkapseling in C ++.

Inkapseling is een van de belangrijkste kenmerken van objectgeoriënteerd programmeren. Het omvat het bundelen van gegevensleden en functies binnen een enkele klasse.

Het samenbrengen van vergelijkbare gegevensleden en functies binnen een klasse helpt ook bij het verbergen van gegevens.

C ++ Inkapseling

Over het algemeen is inkapseling een proces waarbij vergelijkbare code op één plaats wordt verpakt.

In C ++ kunnen we gegevensleden en functies bundelen die samen werken binnen één klasse. Bijvoorbeeld,

 class Rectangle ( public: int length; int breadth; int getArea() ( return length * breadth; ) );

In het bovenstaande programma getArea()berekent de functie de oppervlakte van een rechthoek. Om het gebied te berekenen, heeft het lengte en breedte nodig.

Daarom worden de gegevensleden (lengte en breedte) en de functie bij getArea()elkaar gehouden in de Rectangleklas.

Inkapseling in C ++

Voorbeeld 1: C ++ inkapseling

 // Program to calculate the area of a rectangle #include using namespace std; class Rectangle ( public: // Variables required for area calculation int length; int breadth; // Constructor to initialize variables Rectangle(int len, int brth) : length(len), breadth(brth) () // Function to calculate area int getArea() ( return length * breadth; ) ); int main() ( // Create object of Rectangle class Rectangle rect(8, 6); // Call getArea() function cout << "Area = " << rect.getArea(); return 0; )

Uitvoer

 Gebied = 48

In het bovenstaande voorbeeld berekenen we de oppervlakte van een rechthoek.

Om een gebied te berekenen, moeten we twee variabelen: lengte en breedte en functie: getArea(). Daarom hebben we deze variabelen gebundeld en functioneren ze binnen een enkele klasse met de naam Rectangle.

Hier zijn de variabelen en functies ook toegankelijk vanuit andere klassen. Dit is dus geen gegevens verbergen .

Dit is slechts inkapseling . We houden alleen vergelijkbare codes bij elkaar.

Opmerking: mensen beschouwen inkapseling vaak als het verbergen van gegevens, maar dat is niet helemaal waar.

Inkapseling verwijst naar het bundelen van gerelateerde velden en methoden samen. Dit kan worden gebruikt om gegevens te verbergen. Inkapseling op zichzelf is niet dat gegevens worden verborgen.

Waarom inkapseling?

  • In C ++ helpt inkapseling ons gerelateerde gegevens en functies bij elkaar te houden, waardoor onze code schoner en gemakkelijk te lezen is.
    • Het helpt om de wijziging van onze gegevensleden te controleren.
      Beschouw een situatie waarin we willen dat het lengteveld in een klasse niet-negatief is. Hier kunnen we de lengtevariabele privé maken en de logica binnen de methode toepassen setAge(). Bijvoorbeeld,
       class Rectangle ( private: int age; public: void setLength(int len) ( if (len>= 0) length = len; ) );
    • De getter- en setter-functies bieden alleen-lezen of alleen- schrijven toegang aan onze klasleden. Bijvoorbeeld,
       getLength() // provides read-only access setLength() // provides write-only access
    • Het helpt om componenten van een systeem los te koppelen. We kunnen code bijvoorbeeld in meerdere bundels inkapselen.
      Deze ontkoppelde componenten (bundels) kunnen onafhankelijk en gelijktijdig worden ontwikkeld, getest en debuggen. En eventuele wijzigingen in een bepaald onderdeel hebben geen effect op andere onderdelen.
    • We kunnen ook gegevens verbergen door middel van inkapseling. Als we in voorbeeld 1 de lengte- en breedtevariabelen wijzigen in privateof protected, is de toegang tot deze velden beperkt.
      En ze worden verborgen gehouden voor uiterlijke klassen. Dit wordt het verbergen van gegevens genoemd .

    Gegevens verbergen

    Het verbergen van gegevens is een manier om de toegang van onze gegevensleden te beperken door de implementatiedetails te verbergen. Inkapseling biedt ook een manier om gegevens te verbergen.

    We kunnen toegangsmodificatoren gebruiken om gegevens te verbergen in C ++. Bijvoorbeeld,

    Voorbeeld 2: C ++ - gegevens verbergen met behulp van de privéspecificatie

     #include using namespace std; class Rectangle ( private: // Variables required for area calculation int length; int breadth; public: // Setter function for length void setLength(int len) ( length = len; ) // Setter function for breadth void setBreadth(int brth) ( breadth = brth; ) // Getter function for length int getLength() ( return length; ) // Getter function for breadth int getBreadth() ( return breadth; ) // Function to calculate area int getArea() ( return length * breadth; ) ); int main() ( // Create object of Rectangle class Rectangle rectangle1; // Initialize length using Setter function rectangle1.setLength(8); // Initialize breadth using Setter function rectangle1.setBreadth(6); // Access length using Getter function cout << "Length = " << rectangle1.getLength() << endl; // Access breadth using Getter function cout << "Breadth = " << rectangle1.getBreadth() << endl; // Call getArea() function cout << "Area = " << rectangle1.getArea(); return 0; )

    Uitvoer

     Lengte = 8 Breedte = 6 Oppervlakte = 48

    Hier hebben we de lengte- en breedtevariabelen gemaakt private.

    Dit betekent dat deze variabelen niet rechtstreeks buiten de Rectangleklas kunnen worden benaderd .

    Om toegang te krijgen tot deze particuliere variabelen, hebben we gebruik gemaakt publicfuncties setLength(), getLength(), setBreadth()en getBreadth(). Dit worden getter- en setter-functies genoemd.

    Door de variabelen privé te maken, konden we ongeautoriseerde toegang van buiten de klas beperken. Dit is het verbergen van gegevens .

    Als we proberen toegang te krijgen tot de variabelen uit de main()klasse, krijgen we een foutmelding.

     // error: rectangle1.length is inaccessible rectangle1.length = 8; // error: rectangle1.breadth is inaccessible rectangle1.length = 6;

Interessante artikelen...