Encapsulamento C ++ (com exemplos)

Neste tutorial, aprenderemos sobre encapsulamento em C ++ com a ajuda de exemplos.

O encapsulamento é um dos principais recursos da programação orientada a objetos. Envolve o agrupamento de membros de dados e funções dentro de uma única classe.

Agrupar membros de dados e funções semelhantes dentro de uma classe também ajuda na ocultação de dados.

Encapsulamento C ++

Em geral, o encapsulamento é um processo de agrupar código semelhante em um lugar.

Em C ++, podemos agrupar membros de dados e funções que operam juntos dentro de uma única classe. Por exemplo,

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

No programa acima, a função getArea()calcula a área de um retângulo. Para calcular a área, ele precisa de comprimento e largura.

Portanto, os membros de dados (comprimento e largura) e a função getArea()são mantidos juntos na Rectangleclasse.

Encapsulamento em C ++

Exemplo 1: encapsulamento 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; )

Resultado

 Área = 48

No exemplo acima, estamos calculando a área de um retângulo.

Para calcular uma área, precisamos de duas variáveis: comprimento e largura e uma função: getArea(). Conseqüentemente, agrupamos essas variáveis ​​e funções dentro de uma única classe chamada Rectangle.

Aqui, as variáveis ​​e funções também podem ser acessadas de outras classes. Portanto, isso não é ocultação de dados .

Isso é apenas encapsulamento . Estamos apenas mantendo códigos semelhantes juntos.

Observação: as pessoas costumam considerar o encapsulamento como ocultação de dados, mas isso não é totalmente verdade.

O encapsulamento se refere ao agrupamento de campos e métodos relacionados. Isso pode ser usado para alcançar a ocultação de dados. O encapsulamento em si não é ocultação de dados.

Por que encapsulamento?

  • Em C ++, o encapsulamento nos ajuda a manter dados e funções relacionados juntos, o que torna nosso código mais limpo e fácil de ler.
    • Isso ajuda a controlar a modificação de nossos membros de dados.
      Considere uma situação em que queremos que o campo de comprimento em uma classe seja não negativo. Aqui podemos tornar a variável de comprimento privada e aplicar a lógica dentro do método setAge(). Por exemplo,
       class Rectangle ( private: int age; public: void setLength(int len) ( if (len>= 0) length = len; ) );
    • As funções getter e setter fornecem acesso somente leitura ou somente gravação aos membros de nossa classe. Por exemplo,
       getLength() // provides read-only access setLength() // provides write-only access
    • Ajuda a desacoplar componentes de um sistema. Por exemplo, podemos encapsular o código em vários pacotes.
      Esses componentes desacoplados (pacotes) podem ser desenvolvidos, testados e depurados de maneira independente e simultânea. E quaisquer alterações em um determinado componente não têm efeito em outros componentes.
    • Também podemos obter ocultação de dados usando encapsulamento. No Exemplo 1 , se alterarmos as variáveis ​​de comprimento e largura para privateou protected, o acesso a esses campos será restrito.
      E, eles são mantidos ocultos das classes externas. Isso é chamado de ocultação de dados .

    Ocultação de dados

    A ocultação de dados é uma forma de restringir o acesso de nossos membros de dados, ocultando os detalhes de implementação. O encapsulamento também fornece uma maneira de ocultar os dados.

    Podemos usar modificadores de acesso para conseguir ocultar dados em C ++. Por exemplo,

    Exemplo 2: Ocultação de dados C ++ usando o especificador privado

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

    Resultado

     Comprimento = 8 Largura = 6 Área = 48

    Aqui, criamos as variáveis ​​de comprimento e largura private.

    Isso significa que essas variáveis ​​não podem ser acessadas diretamente fora da Rectangleclasse.

    Para aceder a estas variáveis privadas, que usamos publicfunções setLength(), getLength(), setBreadth()e getBreadth(). Elas são chamadas de funções getter e setter.

    Tornar as variáveis privadas nos permitiu restringir o acesso não autorizado de fora da classe. Isso é ocultação de dados .

    Se tentarmos acessar as variáveis ​​da main()classe, obteremos um erro.

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

Artigos interessantes...