Incapsulamento C ++ (con esempi)

In questo tutorial, impareremo a conoscere l'incapsulamento in C ++ con l'aiuto di esempi.

L'incapsulamento è una delle caratteristiche chiave della programmazione orientata agli oggetti. Implica il raggruppamento di membri di dati e funzioni all'interno di una singola classe.

Il raggruppamento di membri e funzioni di dati simili all'interno di una classe aiuta anche a nascondere i dati.

Incapsulamento C ++

In generale, l'incapsulamento è un processo di avvolgimento di codice simile in un unico punto.

In C ++, possiamo raggruppare membri di dati e funzioni che operano insieme all'interno di una singola classe. Per esempio,

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

Nel programma sopra, la funzione getArea()calcola l'area di un rettangolo. Per calcolare l'area, ha bisogno di lunghezza e larghezza.

Quindi, i membri dei dati (lunghezza e larghezza) e la funzione getArea()sono tenuti insieme nella Rectangleclasse.

Incapsulamento in C ++

Esempio 1: incapsulamento C ++

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

Produzione

 Area = 48

Nell'esempio sopra, stiamo calcolando l'area di un rettangolo.

Per calcolare un'area, abbiamo bisogno di due variabili: la lunghezza e la larghezza e una funzione: getArea(). Quindi, abbiamo raggruppato queste variabili e la funzione all'interno di una singola classe denominata Rectangle.

Qui è possibile accedere alle variabili e alle funzioni anche da altre classi. Quindi, questo non è nascondere i dati .

Questo è solo l' incapsulamento . Stiamo solo tenendo insieme codici simili.

Nota: le persone spesso considerano l'incapsulamento come un nascondiglio dei dati, ma non è del tutto vero.

L'incapsulamento si riferisce al raggruppamento di campi e metodi correlati insieme. Può essere utilizzato per nascondere i dati. L'incapsulamento in sé non significa nascondere i dati.

Perché l'incapsulamento?

  • In C ++, l'incapsulamento ci aiuta a tenere insieme i dati e le funzioni correlate, il che rende il nostro codice più pulito e facile da leggere.
    • Aiuta a controllare la modifica dei nostri dati membri.
      Considera una situazione in cui vogliamo che il campo della lunghezza in una classe non sia negativo. Qui possiamo rendere privata la variabile di lunghezza e applicare la logica all'interno del metodo setAge(). Per esempio,
       class Rectangle ( private: int age; public: void setLength(int len) ( if (len>= 0) length = len; ) );
    • Le funzioni getter e setter forniscono l'accesso di sola lettura o di sola scrittura ai membri della nostra classe. Per esempio,
       getLength() // provides read-only access setLength() // provides write-only access
    • Aiuta a disaccoppiare i componenti di un sistema. Ad esempio, possiamo incapsulare il codice in più bundle.
      Questi componenti disaccoppiati (bundle) possono essere sviluppati, testati e sottoposti a debug in modo indipendente e simultaneo. E qualsiasi modifica in un particolare componente non ha alcun effetto su altri componenti.
    • Possiamo anche ottenere l'occultamento dei dati utilizzando l'incapsulamento. In Esempio 1 , se si cambia la lunghezza ed ampiezza variabili in privateo protected, quindi l'accesso a questi campi è limitato.
      E sono tenuti nascosti alle classi esterne. Questo si chiama nascondere i dati .

    Dati nascosti

    L'occultamento dei dati è un modo per limitare l'accesso dei nostri membri dei dati nascondendo i dettagli di implementazione. L'incapsulamento fornisce anche un modo per nascondere i dati.

    Possiamo usare modificatori di accesso per ottenere l'occultamento dei dati in C ++. Per esempio,

    Esempio 2: nascondere i dati in C ++ utilizzando lo specificatore privato

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

    Produzione

     Lunghezza = 8 Larghezza = 6 Area = 48

    Qui abbiamo creato le variabili di lunghezza e larghezza private.

    Ciò significa che non è possibile accedere direttamente a queste variabili al di fuori della Rectangleclasse.

    Per accedere a queste variabili private, abbiamo utilizzato publicle funzioni setLength(), getLength(), setBreadth()e getBreadth(). Queste sono chiamate funzioni getter e setter.

    Rendere private le variabili ci ha permesso di limitare l'accesso non autorizzato dall'esterno della classe. Questo è nascondere i dati .

    Se proviamo ad accedere alle variabili dalla main()classe, otterremo un errore.

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

Articoli interessanti...