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 {

friend Vetor mult(const Matriz&, const 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)

System.out.println(“Erro”);

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

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