Aula 11 Tipos Abstractos de Dados II. 2003/2004 Introdução à Programação 2 Estrutura global do programa #include using namespace std; int mdc(int const

Aula 11

Tipos Abstractos de Dados II

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

Estrutura global do programa

#include <iostream>#include <cassert>

using namespace std;

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

class Racional {…};

Racional::Racional(int const n) {…}

Racional::Racional(int const n, int const d) {…}

void Racional::escreve() {…}

Racional Racional::somaCom(Racional const& r2) {…}

void Racional::lê() {…}

void Racional::reduz() {…}

bool Racional::cumpreInvariante() {…}

int main() {…}

Diferente!Porquê?


TAD Racional (I)

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

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

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

(continua)


TAD Racional (II)

(continuação)

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

/** 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ê();

(continua)

Diferente!


TAD Racional (III)

(continuação)

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

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

int numerador; int denominador; };


Traçado

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

if(cin.fail()) { cout << "Opps! A leitura dos racion… return 1; }

(continua)


Traçado



(continua)

main()


Traçado



(continua)

Introduza …

main()


Traçado



(continua)

Introduza …

main()

r1: Racional


Traçado

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

assert(cumpreInvariante()); }

Introduza …

Racional::Racional()

main()

r1: Racional

n: int {frozen}

0

*this: Racional&


Traçado



Introduza …


main()

r1: Racional

n: int {frozen}

0

numerador: int

0

*this: Racional&


Traçado



Introduza …


main()

r1: Racional

n: int {frozen}

0

numerador: int

0

denominador: int

1

*this: Racional&


Traçado



Introduza …


main()

r1: Racional

n: int {frozen}

0

numerador: int

0

denominador: int

1

*this: Racional&


Traçado

bool Racional::cumpreInvariante() { return 0 < denominador and

mdc(numerador, denominador) == 1;}

Introduza …

Racional::cumpreInvariante()

main()

r1: Racional

numerador: int

0

denominador: int

1

*this: Racional&


Traçado

bool Racional::cumpreInvariante() { return 0 < denominador and

mdc(numerador, denominador) == 1;}

Introduza …

Racional::cumpreInvariante()

main()

r1: Racional

numerador: int

0

denominador: int

1

*this: Racional&

Devolve verdadeiro.


Traçado



Introduza …


main()

r1: Racional

n: int

0

numerador: int

0

denominador: int

1

*this: Racional&


Traçado



Introduza …


main()

r1: Racional

n: int

0

numerador: int

0

denominador: int

1

*this: Racional&


Traçado



(continua)

Introduza …

main()

r1: Racional

numerador: int

0

denominador: int

1

r2: Racional

numerador: int

0

denominador: int

1


Traçado



(continua)

Introduza …

main()

r1: Racional

numerador = 0denominador = 1

r2: Racional



Traçado



(continua)

Introduza …6 9 7 3

main()

r1: Racional


r2: Racional



Traçado



(continua)


main()

r1: Racional


r2: Racional



Traçado

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


main()

r1: Racional


r2: Racional


Racional::lê()

Sem asserções, para encurtar.

*this: Racional&


Traçado




main()

r1: Racional


r2: Racional


Racional::lê()

n: int

?

d: int

?

*this: Racional&


Traçado




main()

r1: Racional


r2: Racional


Racional::lê()

n: int

?

d: int

?

n: int

6

d: int

9

*this: Racional&


Traçado




main()

r1: Racional


r2: Racional


Racional::lê()

n: int

6

d: int

9

*this: Racional&


Traçado




main()

r1: Racional


r2: Racional


Racional::lê()

n: int

6

d: int

9

*this: Racional&


Traçado




main()

r1: Racional


r2: Racional


Racional::lê()

n: int

6

d: int

9

*this: Racional&


Traçado




main()

r1: Racional


r2: Racional


Racional::lê()

n: int

6

d: int

9

*this: Racional&


Traçado




main()

r1: Racional


r2: Racional


Racional::lê()

n: int

6

d: int

9

*this: Racional&


Traçado




main()

r1: Racional


r2: Racional


Racional::lê()

n: int

6

d: int

9

*this: Racional&

r1: Racional



Traçado




main()

r2: Racional


Racional::lê()

n: int

6

d: int

9

*this: Racional&

r1: Racional


r1: Racional



Traçado




main()

r2: Racional


Racional::lê()

n: int

6

d: int

9

*this: Racional&

r1: Racional


r1: Racional



Traçado

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

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

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

denominador) == 1);}


main()

r2: Racional


Racional::reduz()

*this: Racional&

r1: Racional


r1: Racional



Traçado






main()

r2: Racional


Racional::reduz()

*this: Racional&

r1: Racional


r1: Racional


divisor: int {frozen}

3

Ignoram-se asserções, para encurtar.


Traçado






main()

r2: Racional


Racional::reduz()

*this: Racional&

r1: Racional


r1: Racional



3

r1: Racional



Traçado






main()

r2: Racional


Racional::reduz()

*this: Racional&

r1: Racional



3

r1: Racional



Traçado






main()

r2: Racional


Racional::reduz()

*this: Racional&


3

r1: Racional



Traçado




main()

r2: Racional


Racional::lê()

n: int

6

d: int

9

*this: Racional&

r1: Racional


r1: Racional



Traçado



(continua)


main()

r1: Racional


r2: Racional


r2: Racional



Traçado



(continua)


main()

r1: Racional


r2: Racional



Traçado

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


main()

r1: Racional


r2: Racional


Medonho…


Traçado

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; }


main()

r2: Racional


Racional::somaCom()

*this: Racional&

r1: Racional


r1: Racional


r2: Racional const&


Traçado



r.reduz();


return r; }


main()

r2: Racional


Racional::somaCom()

*this: Racional&

r1: Racional


r1: Racional


r2: Racional const&

r: Racional



Traçado



r.reduz();


return r; }


main()

r2: Racional


Racional::somaCom()

*this: Racional&

r1: Racional


r1: Racional


r2: Racional const&

r: Racional


r: Racional



Traçado



r.reduz();


return r; }


main()

r2: Racional


Racional::somaCom()

*this: Racional&

r1: Racional


r1: Racional


r2: Racional const&

r: Racional


r: Racional



Traçado



r.reduz();


return r; }


main()

r2: Racional


Racional::somaCom()

*this: Racional&

r1: Racional


r1: Racional


r2: Racional const&

r: Racional


Qual será a instância implícita?

r: Racional



Traçado



r.reduz();


return r; }


main()

r2: Racional


Racional::somaCom()

*this: Racional&

r1: Racional


r1: Racional


r2: Racional const&

r: Racional



Traçado

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


main()

r1: Racional


r2: Racional


r: Racional


É igual ao racional devolvido por Racional::somaCom(), mas não é a mesma instância!


Traçado

Etc…..


O nosso objectivo

#include <iostream>

using namespace std;

…

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; }

Hoje ficaremos mais próximos…


Sobrecarga de operadores

Sobrecarga de rotinas possível: int soma() int soma(int const a) int soma(int const a, int const b)

Sobrecarga de operadores também!


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

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

…

private: …

};


Método Racional::operator+()Racional Racional::operator+(Racional const& r2) { assert(cumpreInvariante()); assert(r2.cumpreInvariante());


r.reduz();


return r; }


Função main()

int main(){ …

// Calcular racional soma:

Racional r = r1.operator+(r2);

… }


Função main()

int main(){ …

// Calcular racional soma:

Racional r = r1 + r2;

… }


Sobrecarga de operadores

Como membro de classe: Primeiro operando é instância implícita! Outros operandos são passados como argumentos

Racional Racional::operator+(Racional const& r2)

Como rotina “livre”: Todos os operandos passados como argumentos

Racional operator+(Racional const& r1, Racional const& r2)


Operadores a sobrecarregar

Aritméticos: Binários: *, /, + e - Unários: + e -

Relacionais: <, <=, > e >=

Igualdade e diferença: == e !=

Incrementação: Prefixo: ++ e -- Sufixo: ++ e --

Especiais de atribuição: *=, /=, += e -=

Vamos começar por aqui.


Um problema

Que devolve o operador ++ prefixo?

Exemplo:

int i = 0;++(++i);cout << i << endl;

2

Tem de resultar no próprio i, e não numa cópia.

É um exemplo do que é possível fazer, e não uma sugestão de que é recomendável!


Um caso bicudo

int main(){ int i = 0; ++(++i); cout << i << endl;}


E um regresso às origens

void incrementa(int& v){ v = v + 1;}

int main(){ int i = 0; incrementa(incrementa(i)); cout << i << endl;}

Invocação impossível!incrementa() não devolve nada.


Correcção…

int incrementa(int& v){ v = v + 1;

return v;}



Funcionará?


return v;}



Funcionará?


return v;}


main()


Funcionará?


return v;}


main()

i: int

0


Funcionará?


return v;}


main()

i: int

0


Funcionará?


return v;}


main()

i: int

0

incrementa()

v: int&


Funcionará?


return v;}


main()

i: int

0

incrementa()

v: int&

i: int

1


Funcionará?


return v;}


main()

incrementa()

v: int&

i: int

1

: int

1

Valor devolvido é cópia de v, i.e., é cópia de i. É instância temporária!


Funcionará?


return v;}


main()

i: int

1

: int

1


Funcionará?


return v;}


main()

i: int

1

: int

1

incrementa()

v: int&


Funcionará?


return v;}


main()

i: int

1

: int

1

incrementa()

v: int&

: int

2


Funcionará?


return v;}


main()

i: int

1

incrementa()

v: int&

: int

2

: int

2

Valor devolvido é cópia de v, i.e., é cópia da cópia alterada de i.


Funcionará?


return v;}


main()

i: int

1

: int

2

: int

2


Funcionará?


return v;}


main()

i: int

1

1


Funcionará?


return v;}


main()

i: int

1

1


Moral da história

Segunda incrementação falhou

Ou melhor, incrementou cópia

Porque devolução faz-se por valor

Necessário devolver por referência


Em abono da verdade…

… o código nem sequer compila!

C++ proíbe referência (não constante) para instância temporária!


Outra correcção…

int& incrementa(int& v){ v = v + 1;

return v;}



E agora?


return v;}



E agora?


return v;}


main()


E agora?


return v;}


main()

i: int

0


E agora?


return v;}


main()

i: int

0


E agora?


return v;}


main()

i: int

0

incrementa()

v: int&


E agora?


return v;}


main()

i: int

0

incrementa()

v: int&

i: int

1


E agora?


return v;}


main()

incrementa()

v: int&

i: int

1

: int&


E agora?


return v;}


main()

i: int

1

: int&


E agora?


return v;}


main()

i: int

1

incrementa()

v: int&

: int&


E agora?


return v;}


main()

i: int

1

incrementa()

v: int&

: int&

i: int

2


E agora?


return v;}


main()

i: int

2

incrementa()

v: int&

: int&

: int&


E agora?


return v;}


main()

i: int

2

: int&

: int&


E agora?


return v;}


main()

i: int

2

2


E agora?


return v;}


main()

i: int

2

2


Finalmente… sobrecarga!

int& operator++(int& v){ v = v + 1;

return v;}

int main(){ int i = 0; ++(++i); cout << i << endl;}

Era doce… Não se pode redefinir os operadores dos tipos básicos!

Mas para um TAD pode-se sobrecarregar!


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

/** Incrementa o racional.

@pre *this = r.

@post operator++ = ? *this = r + 1. */ Racional& operator++();

…

private: …

};


Método Racional::operator++()Racional& Racional::operator++() { assert(cumpreInvariante());

numerador += denominador;

assert(cumpreInvariante());

return ?; }

Porque não é necessário reduzir a fracção?

Os TAD devem ter comportamente semelhante aos tipos básicos.Por isso, devia-se devolver o racional incrementado. Como?


Método Racional::operator++()Racional& Racional::operator++() { assert(cumpreInvariante());

numerador += denominador;

assert(cumpreInvariante());

return *this; }


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

/** Incrementa o racional.

@pre *this = r.

@post operator++ ≡ *this *this = r + 1. */ Racional& operator++();

…

private: …

};

O que se devolve é a instância implícita ela própria, e não uma instância temporária com igual valor.


Igualdade vs. identidade

Duas instâncias

São idênticas se forem a mesma instância São iguais se tiverem o mesmo valor Se são idênticas, são também iguais. Podem ser iguais, mas não ser idênticas


Igualdade vs. identidade

int cópia(int const& v){ return v;}

int& mesmo(int& v){ return v;}

int main(){ int i = 0;

mesmo(i) = 10;

cópia(i) = 20;}

Ok.

Erro!


lvalue

Lvalue é uma entidade à qual se pode atribuir um valor

Instâncias temporárias não são lvalues, são rvalues


Aula 11: Sumário

Revisões sobre a aula anterior *this como referência Construção dos atributos: lista de

inicializadores Devolução por valor e por referência Noções de identidade e igualdade Diferença entre lvalue e rvalue Introdução à sobrecarga de operadores para

TAD: operadores + binário e ++ prefixo

Documents

Aula 11 Tipos Abstractos de Dados II. 2003/2004 Introdução à Programação 2 Estrutura global do programa #include using namespace std; int mdc(int const