C ++ beágyazás (példákkal)

Ebben az oktatóanyagban példák segítségével megismerhetjük a C ++ rendszerbe történő beágyazást.

A beágyazás az objektum-orientált programozás egyik legfontosabb jellemzője. Ez magában foglalja az adattagok és a funkciók összekapcsolását egyetlen osztályon belül.

A hasonló adattagok és funkciók osztályon belüli összekapcsolása szintén elősegíti az adatok elrejtését.

C ++ beágyazás

Általában a beágyazás egy hasonló kód egy helyre történő csomagolásának folyamata.

A C ++ - ban olyan adattagokat és funkciókat csomagolhatunk, amelyek egyetlen osztályon belül működnek együtt. Például,

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

A fenti programban a függvény getArea()kiszámítja egy téglalap területét. A terület kiszámításához hosszúságra és szélességre van szükség.

Ezért az adattagokat (hossz és szélesség) és a függvényt getArea()együtt tartják az Rectangleosztályban.

Kapszulázás C ++ nyelven

1. példa: C ++ beágyazás

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

Kimenet

 Terület = 48

A fenti példában egy téglalap területét számoljuk.

Kiszámításához a területen, akkor kell két változó: hossza és szélessége egy funkciót: getArea(). Ezért ezeket a változókat és funkciókat egyetlen Téglalap nevű osztályba csomagoltuk.

Itt a változók és függvények más osztályokból is elérhetők. Ennélfogva ez nem adat rejtegetés .

Ez csak beágyazás . Csak hasonló kódokat tartunk együtt.

Megjegyzés: Az emberek a kapszulázást gyakran rejtegetésnek tekintik, de ez nem teljesen igaz.

A beágyazás a kapcsolódó mezők és módszerek együttes összekapcsolására utal. Ez felhasználható az adatok elrejtésének elérésére. A beágyazás önmagában nem rejtőzik el.

Miért beágyazás?

  • A C ++ nyelven a beágyazás segít a kapcsolódó adatok és funkciók összetartásában, ami kódunkat tisztábbá és könnyebben olvashatóvá teszi.
    • Segít az adattagjaink módosításának ellenőrzésében.
      Vegyünk egy olyan helyzetet, amikor azt akarjuk, hogy az osztályban a hosszúság mezője ne legyen negatív. Itt priváttá tehetjük a hosszúsági változót, és a logikát alkalmazhatjuk a módszeren belül setAge(). Például,
       class Rectangle ( private: int age; public: void setLength(int len) ( if (len>= 0) length = len; ) );
    • A getter és setter funkciók csak olvasható vagy csak írási hozzáférést biztosítanak osztálytagjaink számára. Például,
       getLength() // provides read-only access setLength() // provides write-only access
    • Segít leválasztani a rendszer összetevőit. Például több csomagba foglalhatjuk a kódot.
      Ezeket a leválasztott komponenseket (kötegeket) függetlenül és egyidejűleg lehet fejleszteni, tesztelni és hibakeresni. És egy adott komponens bármilyen változása nincs hatással a többi komponensre.
    • Az adatok elrejtését kapszulázással is elérhetjük. Az 1. példában , ha a hosszúsági és szélességi változókat privatevagy értékre változtatjuk protected, akkor ezekhez a mezőkhöz való hozzáférés korlátozott.
      És rejtve vannak a külső osztályok elől. Ezt hívjuk adat rejtésnek .

    Adatok elrejtése

    Az adatok elrejtése a megvalósítási részletek elrejtésével korlátozhatja adattagjaink hozzáférését. A beágyazás lehetőséget nyújt az adatok elrejtésére is.

    Hozzáférés-módosítókat használhatunk az adatok C ++ nyelven történő elrejtésére. Például,

    2. példa: C ++ adatok elrejtése a privát specifikátor használatával

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

    Kimenet

     Hossz = 8 Szélesség = 6 Terület = 48

    Itt elkészítettük a hosszúság és a szélesség változóit private.

    Ez azt jelenti, hogy ezek a változók nem érhetők el közvetlenül az Rectangleosztályon kívül .

    Az ilyen helyek eléréséhez privát változók, már használt publicfunkciókat setLength(), getLength(), setBreadth()és getBreadth(). Ezeket getter és setter függvényeknek nevezzük.

    A változók priváttá tétele lehetővé tette számunkra, hogy korlátozzuk az illetéktelen hozzáférést az osztályon kívülről. Ez az adatok elrejtése .

    Ha megpróbáljuk elérni a változókat az main()osztályból, hibát kapunk.

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

érdekes cikkek...