aula 10 tipos abstractos de dados i. 2003/2004 introdução à programação 2 flashback lembram-se...

Aula 10

Tipos Abstractos de Dados I

2003/2004Introdução à Programação2

Flashback

Lembram-se da Aula 4?


Soma de fracções (I)

#include <iostream>#include <cassert>

using namespace std;

/** Devolve o máximo divisor comum dos inteiros passados como argumento. @pre m ≠ 0 ou n ≠ 0. @post mdc = mdc(m, n). */int mdc(int const m, int const n) { assert(m != 0 or n != 0);

… }

(continua)

PC relaxada para aceitar inteiros negativos e nulos(ver folhas teóricas)


Soma de fracções (II)

/** Reduz a fracção recebida como argumento. @pre denominador ≠ 0 numerador = n denominador = d. @post denominador ≠ 0 mdc(numerador, denominador ) = 1 numerador/denominador = n/d. */ void reduzFracção(int& numerador, int& denominador) { assert(denominador != 0);

int const divisor = mdc(numerador, denominador);

numerador /= divisor; denominador /= divisor;

assert(denominador != 0); assert(mdc(numerador, denominador) == 1);}

(continua)


Soma de fracções (III)

/** Lê do teclado uma fracção, na forma de dois inteiros sucessivos. @pre numerador = n denominador = d. @post Se cin.good() cin tem dois inteiros n' e d' disponíveis para leitura, com d' ≠ 0, então 0 < denominador mdc(numerador, denominador) = 1 numerador/denominador = n'/d' cin.fail(), senão numerador = n denominador = d cin.fail(). */void lêFracção(int& numerador, int& denominador){ …}

(continua)

int n, d; cin >> n >> d; if(cin.good()) if(d == 0) cin.setstate(ios_base::failbit); else { if(d < 0) { numerador = -n; denominador = -d; } else { numerador = n; denominador = d; } reduzFracção(numerador, denominador);

assert(0 < denominador); assert(mdc(numerador, denominador) == 1); assert(numerador * d == n * denominador); assert(not cin.fail());

return; }

assert(cin.fail());

Não existia na Aula 4!

Garante-se denominador positivo e representação em termos mínimos.


Soma de fracções (IV)

/** Soma duas fracções. @pre denominador1 ≠ 0 denominador2 ≠ 0. @post numerador/ denominador = numerador1/denominador1 + numerador2/denominador2 denominador ≠ 0 mdc(numerador, denominador) = 1. */void somaFracção(int& numerador, int& denominador, int const numerador1, int const denominador1, int const numerador2, int const denominador2) { assert(denominador1 != 0); assert(denominador2 != 0);

numerador = numerador1 * denominador2 + numerador2 * denominador1; denominador = denominador1 * denominador2; reduzFracção(numerador, denominador);

assert(denominador != 0); assert(mdc(numerador, denominador) == 1); }

(continua)

Não existia na Aula 4!


Soma de fracções (V)

/** Escreve uma fracção no ecrã no formato usual. @pre V. @post cout.fail() cout contém n/d (ou simplesmente n, se d = 1) em que n e d são os valores de numerador e denominador. */ void escreveFracção(int const numerador, int const denominador) { cout << numerador; if(denominador != 1) cout << '/' << denominador; }

(continua)


Soma de fracções (VI)

int main(){ // Ler fracções: cout << "Introduza duas fracções (numerador denominador): "; int n1, d1, n2, d2; lêFracção(n1, d1); lêFracção(n2, d2);

if(cin.fail()) { cout << "Opps! A leitura das fracções falhou!" << endl; return 1; }

(continua)


Soma de fracções (VII)

// Calcular fracção soma reduzida: int n, d; somaFracção(n, d, n1, d1, n2, d2);

// Escrever resultado: cout << "A soma de "; escreveFracção(n1, d1); cout << " com "; escreveFracção(n2, d2); cout << " é "; escreveFracção(n, d); cout << '.' << endl; }


Problemas

Dois inteiros para cada fracção Não é possível desenvolver funções para

somar fracções: funções só devolvem um valor

Código complexo e difícil de perceber


Objectivo

Escrever programa para somar fracções tão simples como para somar inteiros

Ou seja…


O nosso objectivo

#include <iostream>


…

int main() { cout << "Introduza duas fracções (numerador denominador): "; Racional r1, r2; cin >> r1 >> r2; if(cin.fail()) { cout << "Opps! A leitura dos racionais falhou!" << endl; return 1; } Racional r = r1 + r2; cout << "A soma de " << r1 << " com " << r2 << " é " << r << '.' << endl; }

Lá chegaremos, lá chegaremos…


Solução

Criar um novo tipo de dados que permita representar um número racional (fracção) com uma só instância

Ou seja, criar um Tipo Abstracto de Dados (TAD)


Tipos Abstractos de Dados (TAD)

Ou Tipos de Primeira Categoria

Características: Tipo definido pelo programador Comporta-se como os tipos básicos Serve para definir variáveis e constantes com

que se pode operar Representado pelas classes C++

Não confundir “classe C++” com “classe” (propriamente dita)…Pormenores só em POO


TAD Racional

/** Representa números racionais. */class Racional { public: int numerador; int denominador;};

Variáveis membro ou atributos

Variáveis membro ou atributos

Atenção ao ; final!


TAD Racional

#include <iostream>#include <cassert>


int mdc(int const m, int const n) { … }

/** Representa números racionais. */class Racional { public: int numerador; int denominador;};

…


Representação gráfica do TAD

Racional

numerador: intdenominador: int

Atributos: instânciasmembro

Operações: rotinasmembro

Nome


Utilização do TAD

Racional r1;Racional r2;

r1.numerador = 6;r1.denominador = 9;

r2.numerador = 7;r2.denominador = 3;

Cada instância de Racional tem os seus próprios atributos!


Representações gráficas (I)

r1: Racional

numerador = ?denominador = ?

r2: Racional

numerador = ?denominador = ?

ObjectosInstâncias do TAD

Há quem lhes chame objectos, mas reservaremos esse nome para as classes propriamente ditas.

r1: Racional

numerador = 6denominador = 9

r2: Racional

numerador = 7denominador = 3


Representações gráficas (II)

r1: Racional

numerador: int

6

denominador: int

9

r2: Racional

numerador: int

7

denominador: int

3


Acesso a membros de instâncias de um TAD

Operador de selecção de membro: .

instância.membro


Função somaDe()

/** Devolve a soma de dois racionais. @pre r1.denominador ≠ 0 r2.denominador ≠ 0. @post somaDe = r1 + r2 somaDe.denominador ≠ 0 mdc(somaDe.numerador, somaDe.denominador) = 1. */ Racional somaDe(Racional const r1, Racional const r2) { assert(r1.denominador != 0); assert(r2.denominador != 0);

Racional r;

r.numerador = r1.numerador * r2.denominador + r2.numerador * r1.denominador; r.denominador = r1.denominador * r2.denominador;

reduz(r);

assert(r.denominador != 0); assert(mdc(r.numerador, r.denominador) == 1);

return r; }

A fazer.

Nome sem sufixo Fracção: redundante dado tipo dos parâmetros.


Procedimento reduz()

/** Reduz a fracção que representa o racional recebido como argumento. @pre r.denominador ≠ 0 r = r. @post r.denominador ≠ 0 mdc(r.numerador, r.denominador) = 1 r = r. */void reduz(Racional const r){ assert(r.denominador != 0);

int const divisor = mdc(r.numerador, r.denominador);

r.numerador /= divisor; r.denominador /= divisor;

assert(r.denominador != 0); assert(mdc(r.numerador, r.denominador) == 1);}

Nome sem sufixo Fracção: redundante dado tipo dos parâmetros.


Procedimento lêPara()

/** Lê do teclado um racional, na forma de dois inteiros sucessivos. @pre r = r.

@post Se cin.good() cin tem dois inteiros n e d disponíveis para

leitura, com d <> 0, então r = n/d cin.fail() 0 < r.denominador mdc(r.numerador, r.denominador) = 1,

senão r = r cin.fail(). */void lêPara(Racional& r) { …}


Procedimento lêPara()

int n, d;

cin >> n >> d; if(not cin.fail()) if(d == 0) cin.setstate(ios_base::failbit); else { if(d < 0) { r.numerador = -n; r.denominador = -d; } else { r.numerador = n; r.denominador = d; } reduz(r);

assert(0 < r.denominador); assert(mdc(r.numerador, r. denominador) == 1); assert(r.numerador * d == n * r.denominador); assert(not cin.fail());

return; }

assert(cin.fail());


Procedimento escreve()

/** Escreve um racional no ecrã no formato de uma fracção. @pre V. @post cout.fail() cout contém n/d (ou simplesmente n, se d = 1) em que n e d são os valores de r.numerador e r.denominador. */ void escreve(Racional const r) { cout << r.numerador; if(r.denominador != 1) cout << '/' << r.denominador; }


Programa principal (I)

int main() { // Ler fracções: cout << "Introduza duas fracções (numerador denominador): "; Racional r1, r2; lêPara(r1); lêPara(r2);

if(cin.fail()) { cout << "Opps! A leitura dos racionais falhou!" << endl; return 1; }

(continua)


Programa principal (II)

// Calcular racional soma: Racional r = somaDe(r1, r2);

// Escrever resultado: cout << "A soma de "; escreve(r1); cout << " com "; escreve(r2); cout << " é "; escreve(r); cout << '.' << endl; }


Inicialização

Para inicializar um racional:

Racional a;a.numerador = 10;a.denominador = 0;

Para inicializar um inteiro:

int a = 10;int a(10);

Mas como inicializar um racional tão simplesmente como um inteiro?

Como evitar inicializações inválidas?


Rotinas membro?

Sim! Classes C++ podem ter rotinas membro! Operação: declaração de rotina membro Método: definição de rotina membro

Diz-se que as classes C++ têm operações que são implementadas por métodos


Construtores (I)

Construir uma instância de um TAD é instanciá-lo

Durante a construção é invocada uma operação especial: um construtor

Como não definimos um construtor, o compilador forneceu um que não faz nada


Construtores: declaração

/** Representa números racionais. */class Racional { public: /** Constrói racional com valor inteiro. @pre V. @post *this = n 0 < denominador mdc(numerador, denominador) = 1. */ Racional(int const n = 0);

/** Constrói racional correspondente a n/d. @pre d ≠ 0. @post *this = n/d 0 < denominador mdc(numerador, denominador) = 1. */ Racional(int const n, int const d);

int numerador; int denominador; };

Construtor invocável sem argumentos: constrói racional 0/1

Construtor que recebe como argumento o numerador: constrói racional n/1

Construtor que recebe como argumentos o numerador e o denominador: constrói racional n/d


Construtores: implementação (I)

class Racional { …

};

Racional::Racional(int const n) : numerador(n), denominador(1){

assert(0 < denominador); assert(mdc(numerador, denominador) == 1); }

(continua)

Lista de inicializadores

Prefixo identifica classe a que o método pertence


Construtores: implementação (II)

Racional::Racional(int const n, int const d) { assert(d != 0);

if(d < 0) { numerador = -n; denominador = -d; } else { numerador = n; denominador = d; }

reduz(*this);

assert(0 < denominador); assert(mdc(numerador, denominador) == 1); assert(numerador * d == n * denominador);}

Variável, ou melhor, instância implícita, ou seja, a instância que está em construção

Acesso directo a atributos da instância impícita


Construtores: implementação (III)


reduz(*this);

Garante-se denominador positivo e representação em termos mínimos.Para quê?


A reter...

*this: explicitação da instância implícita Construtores:

operações com mesmo nome da classe não têm tipo de devolução sobrecarregáveis

Se não forem definidos construtores: C++ fornece um sem parâmetros e que não faz nada

Atributos da instância implícita directamente acessíveis dentro de métodos

Operações declaradas dentro da classe Métodos definidos fora da classe


O que já podemos fazer

Racional r1;Racional r2(6, 9);

escreve(r1);

escreve(r2);

Aparece 0! TAD nunca têm lixo!

Aparece 2/3

Construtores invocados automaticamente


O que ainda podemos fazer...

Racional r(6, 9);r.denominador = 0;

O denominador tem de ser diferente de zero.

Como impedir acesso indevidos?


Categorias de acesso

Os membros podem ser públicos (public) protegidos (protected) privados (private)


Categorias de acesso

Os membros podem ser públicos (public) protegidos (protegidos (protectedprotected)) privados (private)

POO!

Acessíveis por todos

Acessíveis apenas pelos membros da classe


Princípio do encapsulamento

Tudo o que pode ser privado, deve ser privado!

Regra: Todos os atributos das classes devem ser privados

Os construtores da classe foram feitos públicos: porquê?

Excepção: constantes podem ocasionalmente ser públicas


Atributos privados

/** Representa números racionais. */class Racional { public: /** Constrói racional com valor inteiro. @pre V. @post *this = n 0 < denominador mdc(numerador, denominador) = 1. */ Racional(int const n = 0);

/** Constrói racional correspondente a n/d. @pre d ≠ 0. @post *this = n/d 0 < denominador mdc(numerador, denominador) = 1. */ Racional(int const n, int const d);

private: int numerador; int denominador; };


Continua tudo a funcionar?

Racional r(6, 9);

escreve(r);Não tem acesso aos atributos por serem privados.

Faça-se o procedimento membro!


Operação Racional::escreve()/** Representa números racionais. */class Racional { public: …

/** Escreve um racional no ecrã no formato de uma fracção. @pre V. @post cout.fail() ou cout contém n/d (ou simplesmente n, se d = 1) em que n e d são os valores de numerador e denominador. */ void escreve();

private: int numerador; int denominador; }; Operação pública.

Porquê?


Método Racional::escreve()

void Racional::escreve() { cout << numerador; if(denominador != 1) cout << '/' << denominador; }


Invocação de operações

Operador de selecção de membro: .

Racional r1();Racional r2(6, 9);

r1.escreve();r2.escreve();

Numerador de quem?

void Racional::escreve() { cout << numerador; if(denominador != 1) cout << '/' << denominador; }


Operação Racional::somaCom()/** Representa números racionais. */class Racional { public: …

/** Devolve a soma de dois racionais. @pre denominador ≠ 0 r2.denominador ≠ 0. @post somaDe = *this + r2 denominador ≠ 0 somaDe.denominador ≠ 0 mdc(somaDe.numerador, somaDe.denominador) = 1. */ Racional somaCom(Racional const r2);



Método Racional::somaCom()

Racional Racional::somaCom(Racional const r2) { assert(denominador != 0); assert(r2.denominador != 0);

Racional r; r.numerador = numerador * r2.denominador + r2.numerador * denominador; r.denominador = denominador * r2.denominador;

r.reduz();

assert(denominador != 0); assert(r.denominador != 0); assert(mdc(r.numerador, r.denominador) == 1);

return r; }

Soma da instância implícita com r2.


Operação Racional::lê()

/** Representa números racionais. */class Racional { public: …

/** Lê do teclado um racional, na forma de dois inteiros sucessivos. @pre *this = r. @post Se cin.good() cin tem dois inteiros n e d disponíveis para leitura, com d <> 0, então *this = n/d cin.fail() 0 < denominador mdc(numerador, denominador) = 1, senão *this = r cin.fail(). */ void lê();



Método Racional::lê()

void Racional::lê() { …}

int n, d;

cin >> n >> d; if(not cin.fail()) if(d == 0) cin.setstate(ios_base::failbit); else { if(d < 0) { numerador = -n; denominador = -d; } else { numerador = n; denominador = d; } reduz();

assert(0 < denominador); assert(mdc(numerador, denominador) == 1); assert(numerador * d == n * denominador); assert(not cin.fail());

return; }

assert(cin.fail());


Operação Racional::reduz()

/** Representa números racionais. */class Racional { public: …

private: /** Reduz a fracção que representa o racional recebido como argumento. @pre denominador ≠ 0 r = r. @post denominador ≠ 0 mdc(numerador, denominador) = 1 *this = r. */ void reduz();


Operação privada. Porquê?


Método Racional::reduz()

void Racional::reduz() { assert(denominador != 0);

int const divisor = mdc(numerador, denominador); numerador /= divisor; denominador /= divisor;

assert(denominador != 0); assert(mdc(numerador, denominador) == 1);}


Programa principal (I)

int main() { // Ler fracções: cout << "Introduza duas fracções (numerador denominador): "; Racional r1, r2; r1.lê(); r2.lê();

if(cin.fail()) { cout << "Opps! A leitura dos racionais falhou!" << endl; return 1; }

(continua)


Programa principal (II)

(continuação)

// Calcular racional soma: Racional r = r1.somaCom(r2);

// Escrever resultado: cout << "A soma de "; r1.escreve(); cout << " com "; r2.escreve(); cout << " é "; r.escreve(); cout << '.' << endl; }

Horrendo!


E mdc()?

Deveria passar a membro?

Porquê?


Classe é módulo por excelência

Interface Parte pública

Implementação Parte privada Métodos (implementação das operações)

Manual de utilização (contrato) Comentário de documentação da classe Manual de utilização de cada operação pública


Desenho de TAD

Começar sempre:

pela interface e

pelo contrato.


Condição Invariante da Classe

Condição Invariante da Classe (CIC) Racional:

0 < denominador mdc(numerador, denominador) = 1

Condição mais forte que se verifica sempre para todas as instâncias de uma classe

Reflecte as assunções do produtor da classe acerca da sua implementação

Objectivo: verificar erros do programador Deve verificar-se no início e no fim de cada método não-

privado (no final dos construtores)


Operação Racional::cumpreInvariante()

/** Representa números racionais. @invariant 0 < denominador mdc(numerador, denominador) = 1. */class Racional { public: …

private: /** Indica se a CIC se verifica. @pre V. @post cumpreInvariante = 0 < denominador mdc(numerador, denominador) = 1. */ bool cumpreInvariante();



Método Racional::cumpreInvariante()

bool Racional::cumpreInvariante() { return 0 < denominador and mdc(numerador, denominador) == 1;}


Operação Racional::Racional()/** … */class Racional { public: /** Constrói racional com valor inteiro. @pre V. @post *this = n. */ Racional(int const n = 0);

…

private: …};


Método Racional::Racional()Racional::Racional(int const n) : numerador(n), denominador(1){

assert(cumpreInvariante()); }


Operação Racional::Racional()/** … */class Racional { public: …

/** Constrói racional correspondente a n/d. @pre d ≠ 0. @post *this = n/d. */ Racional(int const n, int const d);

…

private: …};


Método Racional::Racional()Racional::Racional(int const n, int const d) { assert(d != 0);


reduz();

assert(cumpreInvariante()); assert(numerador * d == n * denominador);}


Operação Racional::escreve()/** … */class Racional { public: …

/** Escreve um racional no ecrã no formato de uma fracção. @pre V. @post cout.fail() ou cout contém n/d (ou simplesmente n, se d = 1) em que n e d são os valores de numerador e denominador. */ void escreve();

…

private: …};


Método Racional::escreve()

void Racional::escreve() { assert(cumpreInvariante());

cout << numerador; if(denominador != 1) cout << '/' << denominador;

assert(cumpreInvariante());}


Operação Racional::somaCom()/** … */class Racional { public: …

/** Devolve a soma de dois racionais. @pre V. @post somaDe = *this + r2. */ Racional somaCom(Racional const r2);

…

private: …};


Método Racional::somaCom()

Racional Racional::somaCom(Racional const r2) { assert(cumpreInvariante()); assert(r2.cumpreInvariante());

Racional r; r.numerador = numerador * r2.denominador + r2.numerador * denominador; r.denominador = denominador * r2.denominador;

r.reduz();

assert(cumpreInvariante()); assert(r.cumpreInvariante());

return r; }


Operação Racional::lê()

/** … */class Racional { public: …

/** Lê do teclado um racional, na forma de dois inteiros sucessivos. @pre *this = r. @post Se cin.good() cin tem dois inteiros n e d disponíveis para leitura, com d <> 0, então *this = n/d cin.fail(), senão *this = r cin.fail(). */ void lê();

private: …};


Método Racional::lê()

void Racional::lê() { …}

assert(cumpreInvariante());

int n, d;

cin >> n >> d; if(not cin.fail()) if(d == 0) cin.setstate(ios_base::failbit); else { if(d < 0) { numerador = -n; denominador = -d; } else { numerador = n; denominador = d; } reduz();

assert(cumpreInvariante()); assert(numerador * d == n * denominador); assert(not cin.fail());

return; }

assert(cumpreInvariante()); assert(cin.fail());


Aula 10: Sumário

Necessidade de TAD: acrescentando tipos ao C++ Sintaxe da definição de classes C++ Sintaxe da definição de variáveis e constantes de uma classe C++: as instâncias e a

instanciação Variáveis e constantes membro: instâncias membro ou atributos Acesso a atributos membro de uma classe C++: operador de selecção de membro. Rotinas membro:

Operações e métodos Declaração vs. definição. A construção TAD::

Acesso a membros de uma classe C++: a instância implícita Construtores:

Sintaxe Utilização

Parâmetros com argumentos por omissão de novo Categorias e políticas de acesso:

Membros públicos Membros privados

Princípio do encapsulamento: aplicação aos TAD Noção de condição invariante de classe (CIC): regras e vantagens Exemplos com o TAD Racional, para concretização do conceito de número racional

aula 10 tipos abstractos de dados i. 2003/2004 introdução à programação 2 flashback lembram-se...

Documents