C ++ inkapsling (med exempel)

I den här handledningen lär vi oss om inkapsling i C ++ med hjälp av exempel.

Inkapsling är en av de viktigaste funktionerna i objektorienterad programmering. Det involverar buntning av datamedlemmar och funktioner i en enda klass.

Att samla liknande datamedlemmar och funktioner i en klass tillsammans hjälper också till att dölja data.

C ++ inkapsling

I allmänhet är inkapsling en process för att lägga in liknande kod på ett ställe.

I C ++ kan vi samla datamedlemmar och funktioner som fungerar tillsammans i en enda klass. Till exempel,

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

I programmet ovan getArea()beräknar funktionen en rektangel. För att beräkna ytan behöver den längd och bredd.

Följaktligen getArea()hålls datamedlemmarna (längd och bredd) och funktionen tillsammans i Rectangleklassen.

Inkapsling i C ++

Exempel 1: C ++ inkapsling

 // 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; )

Produktion

 Area = 48

I exemplet ovan beräknar vi arean på en rektangel.

För att beräkna ett område behöver vi två variabler: längd och bredd och en funktion: getArea(). Därför samlade vi dessa variabler och fungerar i en enda klass med namnet Rectangle.

Här kan variabler och funktioner nås från andra klasser också. Därför är detta inte datadöljande .

Detta är bara inkapsling . Vi håller bara liknande koder tillsammans.

Obs! Människor anser ofta inkapsling som datadöljande, men det är inte helt sant.

Inkapsling avser sammanfogning av relaterade fält och metoder tillsammans. Detta kan användas för att åstadkomma datadöljande. Inkapsling i sig döljer inte data.

Varför inkapsling?

  • I C ++ hjälper inkapsling oss att hålla samman relaterade data och funktioner, vilket gör vår kod renare och lättläst.
    • Det hjälper till att kontrollera modifieringen av våra datamedlemmar.
      Tänk på en situation där vi vill att längdfältet i en klass ska vara icke-negativt. Här kan vi göra längdvariabeln privat och tillämpa logiken inuti metoden setAge(). Till exempel,
       class Rectangle ( private: int age; public: void setLength(int len) ( if (len>= 0) length = len; ) );
    • Getter- och setterfunktionerna ger skrivskyddad eller skrivbar tillgång till våra klassmedlemmar. Till exempel,
       getLength() // provides read-only access setLength() // provides write-only access
    • Det hjälper till att koppla bort komponenter i ett system. Till exempel kan vi kapsla in kod i flera buntar.
      Dessa frikopplade komponenter (buntar) kan utvecklas, testas och felsökas oberoende och samtidigt. Och alla ändringar i en viss komponent påverkar inte andra komponenter.
    • Vi kan också uppnå datadömning med inkapsling. I exempel 1 , om vi ändrar längd- och breddvariablerna till privateeller protected, är åtkomsten till dessa fält begränsad.
      Och de hålls gömda från yttre klasser. Detta kallas datadöljande .

    Datadöljande

    Datadöljande är ett sätt att begränsa tillgången till våra datamedlemmar genom att dölja implementeringsinformationen. Inkapsling ger också ett sätt att dölja data.

    Vi kan använda åtkomstmodifierare för att uppnå datadöljande i C ++. Till exempel,

    Exempel 2: C ++ datadöljning med den privata specifikatorn

     #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; )

    Produktion

     Längd = 8 Bredd = 6 Area = 48

    Här har vi gjort längd- och breddvariablerna private.

    Detta innebär att dessa variabler inte kan nås direkt utanför Rectangleklassen.

    För att komma åt dessa privata variabler har vi använt publicfunktioner setLength(), getLength(), setBreadth(), och getBreadth(). Dessa kallas getter- och setterfunktioner.

    Att göra variablerna privata gjorde det möjligt för oss att begränsa obehörig åtkomst utanför klassen. Detta är datadöljande .

    Om vi ​​försöker komma åt variablerna från main()klassen får vi ett fel.

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

Intressanta artiklar...