ABSTRAÇÃO processo de representar um grupo de entidades através de seus atributos comuns feita a abstração, cada entidade particular (instância) do grupo é considerada somente pelos seus atributos particulares os atributos comuns às entidades do grupo são desconsiderados (ficam "ocultos" ou "abstraídos")

ABSTRAÇÃO de processos de dados

ABSTRAÇÃO DE PROCESSOS o conceito de abstração de processos é um dos mais antigos no projeto de linguagens absolutamente crucial para a programação historicamente anterior à abstração de dados todos os subprogramas são abstrações de processo exemplo: chamadas sort(array1, len1), sort(array2, len2), ...

MÓDULOS módulos são "containers" sintáticos contendo subprogramas e grupos de dados relacionados logicamente modularização: processo de projetar os módulos de um programa a compreensão do programa pelos mantenedores seria impossível sem organização modularizada além disso, há um ponto crítico: quando o projeto de um programa estende-se por milhares de linhas, recompilá-lo totalmente a cada atualização do código é absolutamente inviável - daí a necessidade de modularizá-lo

ENCAPSULAMENTO um agrupamento de subprogramas+dados que é compilado separada/independentemente chama-se uma unidade de compilação ou um encapsulamento um encapsulamento é portanto um sistema abstraído muitas vezes os encapsulamentos são colocados em bibliotecas exemplo: encapsulamentos C (não são seguros porque não há verificação de tipos de dados em diferentes arquivos de encapsulamento)

OBJETOS um tipo abstrato de dados é um encapsulamento que inclui somente um tipo específico de dado e os subprogramas que fornecem as operações para este tipo detalhes de implementação do tipo ficam ocultos das unidades fora do encapsulamento que o contém um objeto é uma variável (instância) de um tipo abstrato de dados, declarada por alguma unidade programação orientada a objetos consiste no uso de objetos no desenvolvimento do software

EXEMPLO: O PONTO-FLUTUANTE COMO TIPO ABSTRATO DE DADOS embora o tipo ponto-flutuante esteja presente desde o início da programação, raramente nos referimos a ele como tipo abstrato de dados praticamente todas as linguagens permitem que se criem "objetos" do tipo ponto-flutuante observe que existe um conjunto de operações que são válidas para o tipo ponto-flutuante, exatamente como os “métodos” definidos para uma “classe” além disso, a ocultação da informação está presente: o formato real dos dados é inacessível ao programador - isto é exatamente o que se espera de uma abstração isto é o que permite a portabilidade de um programa entre as implementações da linguagem para plataformas particulares

TIPOS DE DADOS ABSTRATOS DEFINIDOS PELO USUÁRIO a definição do tipo e as operações sobre objetos do tipo estão contidas numa única unidade sintática outras unidades de programa podem ter permissão para criar variáveis do tipo definido a implementação do tipo não é visível pelas unidades de programa que usam o tipo as únicas operações possíveis sobre objetos do tipo são aquelas oferecidas na definição do tipo

CLIENTES unidades de programa que utilizam um tipo abstrato chamam-se clientes daquele tipo a ocultação da representação do tipo abstrato é vantajoso para seus clientes: o código no cliente não depende desta representação, e mudanças na representação não exigem mudanças nos clientes (mas se o protocolo de alguma operação for modificado, então é claro que os clientes precisam ser alterados) a ocultação aumenta a confiabilidade: nenhum cliente pode interferir intencional ou acidentalmente na representação

EXEMPLO: UMA PILHA E SUAS OPERAÇÕES ABSTRATAS create(stack) destroy(stack) empty(stack) push(stack, elem) pop(stack) top(stack) create(STK1); % STK1 é um objeto ou uma instância do tipo stack create(STK2); % outra instância do tipo stack

TIPOS DE DADOS ABSTRATOS EM C++ os tipos abstratos de dados em C++ são as chamadas classes as variáveis são declaradas como instâncias de classes classes do C++ são baseadas nas da SIMULA67 e no struct do C os dados definidos numa classe são os membros de dados

FUNÇÕES-MEMBRO as funções definidas em uma classe são as funções-membro as funções-membro são compartilhadas por todas as instâncias de classe mas: cada instância tem seu próprio conjunto de membros de dados uma função membro pode ter sua definição completa dentro da classe ("inlined") ou apenas seu cabeçalho

TEMPO DE VIDA DAS CLASSES as instâncias de classe podem ser estáticas, stack-dinâmicas ou heap-dinâmicas, exatamente como variáveis do C as classes podem incluir membros de dados heap-dinâmicos, não obstante elas próprias não serem heap-dinâmicas

OCULTAÇÃO DA INFORMAÇÃO EM C++ cláusula private: para entidades ocultas na classe cláusula public: para as entidades visíveis aos clientes. Descreve a interface com objetos da classe cláusula protected: relacionada com herança

Construtores Funções-membro usadas para inicializar os membros de dados de um objeto recém-criado Também alocam membros de dados heap-dinâmicos Têm o mesmo nome da classe Pode-se sobrecarregar construtores Não têm tipo de retorno, não usam return

Destrutores Implicitamente chamados quando se encerra o tempo de vida de um objeto Se um objeto é heap-dinâmico, será explicitamente desalocado com delete O destrutor pode conter chamadas delete para desalocar membros de dados heap-dinâmicos Nome do destrutor: ~ <nome_da_classe> Não têm tipo de retorno, não usam return

Exemplo #include <iostream.h> class pilha { private: int *ptr_pilha; int tam_max; int top_ptr ; public: pilha( ){ //** um construtor ptr_pilha = new int [100]; tam_max = 99; top_ptr = -1; }

Exemplo (continuação) ... ~pilha( ){ //** um destrutor delete [ ] ptr_pilha; } void push ( int elem) { if (top_ptr = = tam_max) cout << “Erro - pilha cheia\n”; else ptr_pilha[ + + top_ptr ] = elem; void pop ( ) { if (top_ptr = = -1) cout << “Erro - pilha vazia\n”; else top_ptr -- ;

Exemplo (continuação) ... int top { return ( ptr_pilha[top_ptr] ); } int empty { return ( top_ptr = = -1 ); } } \\** fim da classe pilha Código no cliente: void main ( ) { int top_one; pilha stk; stk.push(42); stk.push(17); top_one = stk.top( ); stk.pop( ); ... }

Avaliação das classes C++ As classes são tipos Não há construções de encapsulamento generalizadas Exemplo: temos uma classe “matriz” e uma classe “vetor”, e precisamos multiplicar um objeto “matriz” por um objeto “vetor”. Em qual classe essa operação deve ser definida?

Solução para “matriz  vetor” class Matriz { friend Vetor mult(const Matriz&, const Vetor&); ...} class Vetor { Vetor mult(const Matriz& m1, const Vetor& v1){ ..} Se Matriz e Vetor pudessem ser definidas num único pacote, evitaríamos esta construção pouco natural.

Java Suporte para tipos abstratos similar a C++ Todos os tipos de dados definidos pelo usuário são classes Todos os objetos são heap-dinâmicos e acessados por variáveis de referência Todos os subprogramas (métodos) em Java somente podem ser definidos em classes public e private são modificadores anexados às definições de métodos/variáveis

Java Suporte para tipos abstratos similar a C++ Todos os tipos de dados definidos pelo usuário são classes Todos os objetos são heap-dinâmicos e acessados por variáveis de referência Todos os subprogramas (métodos) em Java somente podem ser definidos em classes public e private são modificadores anexados às definições de métodos/variáveis

Pacotes Java Em C++ as classes são a única construção de encapsulamento Java inclui uma construção adicional: os pacotes Pacotes podem conter mais de uma classe public e private são os chamados modificadores Os membros sem modificador (e os membros public) de uma classe são visíveis a todas as classes do mesmo pacote (escopo de pacote) Não há, portanto, necessidade de declarações friend explícitas em Java

Exemplo import java.io.* class Pilha { private int [ ] ref_pilha; private int tam_max, top_index ; public Pilha( ){ // um construtor ref_pilha = new int [100]; tam_max = 99; top_index = -1; }

Exemplo (continuação) ... public void push ( int elem) { if (top_index = = tam_max) System.out.println(“Erro”); else ref_pilha[ + + top_index ] = elem; } public void pop ( ) { if (top_index = = -1) else --top_index ; public int top { return ( ref_pilha[top_index] ); } public boolean empty { return ( top_index = = -1 ); } } \\** fim da classe Pilha

Exemplo (continuação) - uso da classe Pilha public class Testa_Pilha { public static void main (String [ ] args) { Pilha p1 = new Pilha( ); p1.push(42); p1.push(29); p1.pop( ); p1.pop( ); // Produz msg de erro ... } Não há destrutor (eliminado pela coleta de lixo implícita em Java) Observe o uso de variável de referência em vez de ponteiro

Classes parametrizadas em C++ Exemplo: suponha que o método construtor para a classe pilha fosse: pilha (int size ){ ptr_pilha = new int [size]; tam_max = size-1; top_ptr = -1; } No cliente: ... pilha(150) p1;

Classes genéricas em C++ #include <iostream.h> template < class TIPO > class pilha { private: TIPO *ptr_pilha; int tam_max; int top_ptr ; public: pilha( ){ //** um construtor ptr_pilha = new TIPO [100]; tam_max = 99; top_ptr = -1; }

Classes genéricas em C++ (continuação) pilha (int size ){ // outro construtor sobrecarregado ptr_pilha = new TIPO [size]; tam_max = size-1; top_ptr = -1; } ~pilha( ){ delete ptr_pilha; } void push ( TIPO elem) { if (top_ptr = = tam_max) cout << “Erro - pilha cheia\n”; else ptr_pilha[ + + top_ptr ] = elem; void pop ( ) {...}

Classes genéricas em C++ (continuação) ... TIPO top { return ( ptr_pilha[top_ptr] ); } int empty { return ( top_ptr = = -1 ); } } \\** fim da classe pilha