Abstração de dados em C++

A abstração de dados refere-se a fornecer apenas informações essenciais para o mundo exterior e ocultar seus detalhes de fundo, ou seja, representar as informações necessárias no programa sem apresentar os detalhes.

A abstração de dados é uma técnica de programação (e design) que se baseia na separação de interface e implementação.

Vamos dar um exemplo da vida real de uma TV, que você pode ligar e desligar, mudar o canal, ajustar o volume e adicionar componentes externos, como alto-falantes, videocassetes e DVD players, MAS você não conhece seus detalhes internos, que ou seja, você não sabe como ele recebe sinais pelo ar ou por um cabo, como ele os traduz e, finalmente, os exibe na tela.

Assim, podemos dizer que uma televisão separa claramente sua implementação interna de sua interface externa e você pode brincar com suas interfaces como o botão liga / desliga, trocador de canal e controle de volume sem ter nenhum conhecimento de suas partes internas.

Em C++, as classes fornecem um ótimo nível de abstração de dados . Eles fornecem métodos públicos suficientes para o mundo exterior para brincar com a funcionalidade do objeto e manipular os dados do objeto, ou seja, estado sem realmente saber como a classe foi implementada internamente.

Por exemplo, seu programa pode fazer uma chamada para sort() função sem saber qual algoritmo a função realmente usa para classificar os valores fornecidos. Na verdade, a implementação subjacente da funcionalidade de classificação pode mudar entre as versões da biblioteca e, desde que a interface permaneça a mesma, sua chamada de função ainda funcionará.

Em C++, usamos classes para definir nossos próprios tipos de dados abstratos (ADT). Você pode usar o cout objeto da classe ostream para transmitir dados para a saída padrão como esta -
Demonstração ao vivo

#include <iostream>
using namespace std;

int main() {
   cout << "Hello C++" <<endl;
   return 0;
}

Aqui, você não precisa entender como cout exibe o texto na tela do usuário. Você precisa conhecer apenas a interface pública e a implementação subjacente de 'cout' pode ser alterada.

Os rótulos de acesso impõem abstração

Em C++, usamos rótulos de acesso para definir a interface abstrata para a classe. Uma classe pode conter zero ou mais rótulos de acesso -

• 
  Os membros definidos com um rótulo público são acessíveis a todas as partes do programa. A exibição de abstração de dados de um tipo é definida por seus membros públicos.
  
• 
  Os membros definidos com um rótulo privado não são acessíveis ao código que usa a classe. As seções privadas ocultam a implementação do código que usa o tipo.
  

Não há restrições sobre a frequência com que um rótulo de acesso pode aparecer. Cada rótulo de acesso especifica o nível de acesso das definições de membros seguintes. O nível de acesso especificado permanece em vigor até que o próximo rótulo de acesso seja encontrado ou a chave direita de fechamento do corpo da classe seja vista.

Benefícios da abstração de dados

A abstração de dados oferece duas vantagens importantes -

• 
  Os internos de classe são protegidos contra erros inadvertidos no nível do usuário, que podem corromper o estado do objeto.
  
• 
  A implementação da classe pode evoluir ao longo do tempo em resposta a mudanças de requisitos ou relatórios de bugs sem exigir alterações no código de nível de usuário.
  

Ao definir membros de dados apenas na seção privada da classe, o autor da classe fica livre para fazer alterações nos dados. Se a implementação mudar, apenas o código da classe precisa ser examinado para ver o efeito que a mudança pode ter. Se os dados forem públicos, qualquer função que acesse diretamente os membros de dados da representação antiga poderá ser interrompida.

Exemplo de abstração de dados

Qualquer programa C++ em que você implementa uma classe com membros públicos e privados é um exemplo de abstração de dados. Considere o seguinte exemplo -
Demonstração ao vivo

#include <iostream>
using namespace std;

class Adder {
   public:
      // constructor
      Adder(int i = 0) {
         total = i;
      }
      
      // interface to outside world
      void addNum(int number) {
         total += number;
      }
      
      // interface to outside world
      int getTotal() {
         return total;
      };
      
   private:
      // hidden data from outside world
      int total;
};

int main() {
   Adder a;
   
   a.addNum(10);
   a.addNum(20);
   a.addNum(30);

   cout << "Total " << a.getTotal() <<endl;
   return 0;
}

Quando o código acima é compilado e executado, ele produz o seguinte resultado -

Total 60

A classe acima soma os números e retorna a soma. Os membros públicos - addNum e getTotal são as interfaces para o mundo exterior e um usuário precisa conhecê-las para usar a classe. O membro privado total é algo que o usuário não precisa saber, mas é necessário para que a classe funcione corretamente.

Estratégia de design

A abstração separa o código em interface e implementação. Portanto, ao projetar seu componente, você deve manter a interface independente da implementação para que, se você alterar a implementação subjacente, a interface permaneça intacta.

Nesse caso, quaisquer que sejam os programas que estejam usando essas interfaces, eles não seriam afetados e precisariam apenas de uma recompilação com a implementação mais recente.