Aula 13 Tipos Abstractos de Dados IV. 2003/2004 Introdução à Programação 2 Estrutura global do...

Aula 13

Tipos Abstractos de Dados IV

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

Estrutura global do programa (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) {…}

class Racional {…};

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

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

int Racional::numerador() {…}

int Racional::denominador() {…}

void Racional::escreve() {…}

(continua)(continua)

Construtores

Inspectores


Estrutura global do programa (II)

(continuação)(continuação)

void Racional::lê() {…}

Racional& Racional::operator++() {…}

Racional& Racional::operator--() {…}

Racional& Racional::operator*=(Racional const& r2) {…}

Racional& Racional::operator/=(Racional const& r2) {…}

Racional& Racional::operator+=(Racional const& r2) {…}

Racional& Racional::operator-=(Racional const& r2) {…}

void Racional::reduz() {…}

bool Racional::cumpreInvariante() {…}


Modificadores

Auxiliares


Estrutura global do programa (III)


/** Produto de dois racionais. @pre V. @post operator* = r1 × r2. */Racional const operator*(Racional r1, Racional const& r2) {…}

/** Divisão de dois racionais. @pre r2 ≠ 0. @post operator/ = r1 / r2. */Racional const operator/(Racional r1, Racional const& r2) {…} /** Soma de dois racionais. @pre V. @post operator+ = r1 + r2. */Racional const operator+(Racional r1, Racional const& r2) {…}

/** Subtracção de dois racionais. @pre V. @post operator- = r1 - r2. */Racional const operator-(Racional r1, Racional const& r2) {…}


Operadores aritméticos

não-membro


Estrutura global do programa (IV)


/** Indica se dois racionais são iguais.

@pre V.

@post operator== = (r1 = r2). */bool operator==(Racional const& r1, Racional const& r2) {…} /** Indica se dois racionais são diferentes.

@pre V.

@post operator!= = (r1 ≠ r2). */bool operator!=(Racional const& r1, Racional const& r2) {…}

int main() {…}

Operadores de igualdade e

diferençanão-membro


TAD Racional (construtores)

/** Representa números racionais.

@invariant 0 < denominador_ mdc(numerador_, denominador_) = 1. */class Racional { public: /** Constrói racional com valor inteiro.

@pre V.

@post *this = valor. */ Racional(int const valor = 0);

/** Constrói racional correspondente a numerador/denominador.

@pre denominador ≠ 0.

@post *this = numerador/denominador. */ Racional(int const numerador, int const denominador);



TAD Racional (inspectores)

(continuação)(continuação) /** Devolve numerador da fracção mínima correspondente ao racional. @pre V. @post numerador/denominador() = *this. */ int numerador();

/** Devolve denominador da fracção mínima correspondente ao racional. @pre V. @post 0 < denominador (E n : V : n/denominador = *this mdc(n, denominador) = 1). */ int denominador();

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


TAD Racional (modificadores)

(continuação)(continuação) /** 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ê();

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

/** Decrementa o racional. @pre *this = r. @post operator-- ≡ *this *this = r - 1. */ Racional& operator--(); (continua)(continua)



(continuação)(continuação) /** Multiplica por um racional. @pre *this = r. @post operator*= ≡ *this *this = r × r2. */ Racional& operator*=(Racional const& r2);

/** Divide por um racional. @pre *this = r r2 ≠ 0. @post operator/= ≡ *this *this = r / r2. */ Racional& operator/=(Racional const& r2);

/** Adiciona de um racional. @pre *this = r. @post operator+= ≡ *this *this = r + r2. */ Racional& operator+=(Racional const& r2);

/** Subtrai de um racional. @pre *this = r. @post operator-= ≡ *this *this = r - r2. */ Racional& operator-=(Racional const& r2);(continua)(continua)


TAD Racional (implementação)

(continuação)(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_; };


Constantes de TAD

Possível definir constantes de TAD:

Racional const um_terço(1, 3);

Mas é necessário ter alguns cuidados:

cout << um_terço.numerador() << endl;

Porque não

Racional const um_terço(1 / 3);

?

Dá erro!


Constantes de TAD

Compilador admite, por omissão, que as operações alteram a instância implícita

Se a instância implícita for constante, não se podem invocar operações??

Podem, mas apenas as operações que declararem explicitamente que não alteram a instância implícita, pois a tratam como constante


Operações que garantem constância: Sintaxe

class Classe { …

tipo operação(parâmetros) const; …

};

tipo Classe::operação(parâmetros) const { …

}


Operações que garantem constância: Semântica

Podem ser invocadas usando constantes:

Classe const constante;

constante.operação(argumentos);

Proibido para operações não constantes.



Compilador impede método de fazer alterações aos atributos:

tipo Classe::operação(parâmetros) const{ …

atributoatributo = = ……;; …

} Proibido!



Métodos não-constantes

*this é Classe&

Métodos constantes

*this é Classe const&





@pre V.






Construtores não podem ser const, pois instância implícita é por eles inicializada!



(continuação)(continuação) /** Devolve numerador da fracção mínima correspondente ao racional. @pre V. @post numerador/denominador() = *this. */ int numerador() const;

/** Devolve denominador da fracção mínima correspondente ao racional. @pre V. @post 0 < denominador (E n : V : n/denominador = *this mdc(n, denominador) = 1). */ int denominador() const;

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

Inspectores são sempre const!

Aos inspectores também se chama interrogações (queries)







Modificadores nunca são const!



(continuação)(continuação) private: /** Indica se a CIC se verifica. @pre V. @post cumpreInvariante = 0 < denominador_ mdc(numerador_, denominador_) = 1. */ bool cumpreInvariante() const;




Métodos afectados

…

int Racional::numerador() const {…}

int Racional::denominador() const {…}

void Racional::escreve() const {…}

…

bool Racional::cumpreInvariante() const {…}

…


Métodos afectados

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

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

assert(cumpreInvariante());} Desnecessário! Num método

constante, se o invariante se verifica no início (para a instância implícita), também se verifica no fim.

(Hmmm… Há excepções. )


Métodos afectados

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

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


Atenção!

Utilização sistemática de const tem grandes vantagens: Obriga programador a pensar

(menos erros) Programador explicita informação acerca do

programa, que o compilador usa para detectar incoerências (erros detectados mais facilmente)

Erros ocorrem mais cedo, durante compilação (erros detectados mais cedo)


Desafio

Quantas invocações de rotinas estão envolvidas em

Racional r(1, 3);

Racional s = r + 2;

ignorando asserções?

Dica:

Quando se constrói um racional à custa de outro, é invocado um construtor por cópia, fornecido automaticamente pelo compilador, e que se limita a copiar os atributos um a um.


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

assert(cumpreInvariante()); assert(cumpreInvariante());

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


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

if(d < 0) { numerador_ = -n; denominador_ = -d; } else { numerador_ = n; denominador_ = d; }

reduz();

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


Inspector Racional::numerador()int Racional::numerador() const{ assert(cumpreInvariante()); assert(cumpreInvariante());

return numerador_; }


Inspector Racional::denominador()int Racional::denominador() const{ assert(cumpreInvariante()); assert(cumpreInvariante());

return denominador_; }


Operador Racional::operator+=()Racional& Racional::operator+=(Racional const& r2) { assert(cumpreInvariante());assert(cumpreInvariante()); assert(r2.cumpreInvariante()); assert(r2.cumpreInvariante());

numerador_ = numerador() * r2.denominador() + r2.numerador() * denominador(); denominador_ *= r2.denominador();

reduz();


return *this; }


Método auxiliar Racional::reduz()void Racional::reduz(){ assert(denominador_ != 0); assert(denominador_ != 0);

int const divisor = mdc(numerador_, denominador_);

numerador_ /= divisor; denominador_ /= divisor;

assert(denominador_ != 0);assert(denominador_ != 0);

assert(mdc(numerador_, denominador_) == 1);assert(mdc(numerador_, denominador_) == 1);}


Operador Racional::operator+()Racional const operator+(Racional r1, Racional const& r2) { r1 += r2;

return r1; }


Operador Racional::operator==()bool operator==(Racional const& r1, Racional const& r2) { return r1.numerador() == r2.numerador() and r1.denominador() == r2.denominador(); }


Traçado

Racional r(1, 3);

Racional s = r + 2;

Número de invocações:

0


Traçado

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


reduz();



1


Traçado



reduz();



1


Traçado

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






2


Traçado







2


Traçado

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

}


3


Traçado


}


3


Traçado







3


Traçado



reduz();



3


Traçado

Racional r(1, 3);

Racional s = r + 2;


3


Traçado

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




4


Traçado

Racional r(1, 3);

Racional s = r + 2;


4


Traçado

Racional const operator+(Racional r1, Racional const& r2) { r1 += r2;

return r1; }

Passagem por valor implica cópia!


5


Traçado

Racional::Racional(Racional const& original) : numerador_(original.numerador_), denominador_(original.denominador_){}

Construtor por cópia fornecido automaticamente pelo compilador.


6


Traçado



6


Traçado


return r1; }


6


Traçado

Racional& Racional::operator+=(Racional const& r2) { assert(cumpreInvariante());assert(cumpreInvariante()); assert(r2.cumpreInvariante()); assert(r2.cumpreInvariante());


reduz();


return *this; }


7


Traçado



reduz();


return *this; }


7


Traçado

int Racional::numerador() const{ assert(cumpreInvariante()); assert(cumpreInvariante());



8


Traçado




8


Traçado



reduz();


return *this; }


8


Traçado

int Racional::denominador() const{ assert(cumpreInvariante()); assert(cumpreInvariante());



9


Traçado




9


Traçado



reduz();


return *this; }


9


Traçado




10


Traçado



reduz();


return *this; }


10


Traçado




11


Traçado



reduz();


return *this; }


11


Traçado




12


Traçado



reduz();


return *this; }


12


Traçado







13


Traçado


}


14


Traçado







14


Traçado



reduz();


return *this; }


14


Traçado


return r1; }

Devolução por valor implica cópia!


14


Traçado



15


Traçado

Racional r(1, 3);

Racional s = r + 2;


15


Traçado



16


Traçado

Racional r(1, 3);

Racional s = r + 2;

// Fim!


16


Conclusão

Há muito mais invocações do que suspeitávamos: 16!

Cada invocação implica: Colocar endereço de retorno na pilha Construir parâmetros na pilha Executar corpo Destruir parâmetros da pilha Construir instância de devolução (se for o caso) Retornar ao local de invocação

Ok, ok… Uma das cópias provavelmente não seria feita…


Eficiência

Dados Programa passa 80% do tempo em 20% do

código 20% críticos desconhecidos a priori

Conclusões Esforços de optimização antecipados são perda

de tempo


Mas…

Há hábitos que contribuem para eficiência do programa e não têm qualquer desvantagem:

1. Usar passagem de argumentos por referência constante onde apropriado

2. Usar a palavra chave inline onde apropriado

Já se lá irá, já se lá irá…


Rotinas em-linha (inline)

Corpo não existe num único local, sendo executado sempre que desejado

Corpo é substituído pelo compilador em todos os locais onde a rotina é invocada

Rotinas curtas e sem ciclos devem ser em-linha!

Duas ou três linhas, digamos, excluindo asserções.


Exemplo

inline int soma(int const a, int const b){ return a + b; }

int x1 = 10;int x2 = 30;int x3 = 50;int r = 0;

int main(){ r = soma(x1, x2); r = soma(r, x3); }


int main(){ r = x1 + x2; r = r + x3; }

Geram mesmo código máquina!Geram mesmo código máquina!

Usar variáveis globais é má ideia! Isto é só um

exemplo!


Exemplo em MAC-1

int soma(int const a, int const b){ return a + b; }



jump main # Variáveis: x1 = 10 x2 = 30 x3 = 50 r = 0 # Aqui faz-se a soma:main: lodd x1 # Carrega variável x1 no acumulador. push # Coloca acumulador no topo da pilha. lodd x2 # Carrega variável x2 no acumulador. push # Coloca acumulador no topo da pilha. # Aqui a pilha tem os dois argumentos x1 e x2: call soma # Invoca a função soma. insp 2 # Repõe a pilha (limpeza da casa). # Aqui o acumulador tem o valor devolvido. stod r # Guarda o acumulador na variável r. lodd r # Carrega variável r no acumulador. push # Coloca acumulador no topo da pilha. lodd x3 # Carrega variável x3 no acumulador. push # Coloca acumulador no topo da pilha. # Aqui a pilha tem os dois argumentos r e x3: call soma # Invoca a função soma. insp 2 # Repõe a pilha (limpeza da casa). # Aqui o acumulador tem o valor devolvido. stod r # Guarda o acumulador na variável r. haltsoma: lodl 2 addl 1 retn

Sem inline (nem optimização).

compilação


jump main1030500

lodd x1push

lodd x2push

call somainsp 2stod rlodd rpush

lodd x3push

call somainsp2stod rhalt

lodl 2addl 1retn

????????

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

0pc

?ac

100sp

10099989796959493

…

pilha

Instruções executadas:

0


jump main10

0lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

5pc

?ac

100sp

10099989796959493

3050

????????

…


1


jump main10

0lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

6pc

10ac

100sp

10099989796959493

3050

????????

…


2


jump main10

0lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

10

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

7pc

10ac

99sp

10099989796959493

3050

??????

?

…


3


jump main10

0lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

10

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

8pc

30ac

99sp

10099989796959493

3050

??????

?

…


4


jump main10

0lodd x1push

lodd x2push


lodd x3push


lodl 1addl 2retn

3010

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

9pc

30ac

98sp

10099989796959493

3050

?????

?

…


5


jump main10

0lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

103010

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

20pc

30ac

97sp

10099989796959493

3050

????

?

…


6


jump main10

0lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

103010

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

21pc

10ac

97sp

10099989796959493

3050

????

?

…


7


jump main10

0lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

103010

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

22pc

40ac

97sp

10099989796959493

3050

????

?

…


8


jump main10

0lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

103010

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

10pc

40ac

98sp

10099989796959493

3050

????

?

…


9


jump main10

0lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

103010

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

11pc

40ac

100sp

10099989796959493

3050

????

?

…


10


jump main10

40lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

103010

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

12pc

40ac

100sp

10099989796959493

3050

????

?

…


11


jump main10

40lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

103010

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

13pc

40ac

100sp

10099989796959493

3050

????

?

…


12


jump main10

40lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

103040

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

14pc

40ac

99sp

10099989796959493

3050

????

?

…


13


jump main10

40lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

103040

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

15pc

50ac

99sp

10099989796959493

3050

????

?

…


14


jump main10

40lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

105040

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

16pc

50ac

98sp

10099989796959493

3050

????

?

…


15


jump main10

40lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

175040

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

20pc

50ac

97sp

10099989796959493

3050

????

?

…


16


jump main10

40lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

175040

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

21pc

40ac

97sp

10099989796959493

3050

????

?

…


17


jump main10

40lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

175040

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

22pc

90ac

97sp

10099989796959493

3050

????

?

…


18


jump main10

40lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

175040

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

17pc

90ac

98sp

10099989796959493

3050

????

?

…


19


jump main10

40lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

175040

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

18pc

90ac

100sp

10099989796959493

3050

????

?

…


20


jump main10

90lodd x1push

lodd x2push


lodd x3push


lodl 2addl 1retn

175040

soma: 202122

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

10111213141516171819

19pc

90ac

100sp

10099989796959493

3050

????

?

…


21


Exemplo em MAC-1

inline int soma(int const a, int const b){ return a + b; }



jump main # Variáveis: x1 = 10 x2 = 20 x3 = 30 r = 0 # Aqui faz-se a soma:main: lodd x1 # Carrega variável x1 no acumulador. addd x2 # Adiciona variável x2 ao acumulador. stod r # Guarda o acumulador na variável r. lodd r # Carrega variável r no acumulador. addd x3 # Adiciona variável x3 ao acumulador. stod r # Guarda o acumulador na variável r. halt

Com inline.

compilação


jump main1030500

lodd x1addd x2stod rlodd r

addd x3stod rhalt

????????

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

1011

0pc

?ac

100sp

10099989796959493

…

pilha


0


jump main1030500


addd x3stod rhalt

????????

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

1011

5pc

?ac

100sp

10099989796959493

…


1


jump main1030500


addd x3stod rhalt

????????

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

1011

6pc

10ac

100sp

10099989796959493

…


2


jump main1030500


addd x3stod rhalt

????????

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

1011

7pc

40ac

100sp

10099989796959493

…


3


jump main10305040


addd x3stod rhalt

????????

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

1011

8pc

40ac

100sp

10099989796959493

…


4


jump main10305040


addd x3stod rhalt

????????

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

1011

9pc

40ac

100sp

10099989796959493

…


5


jump main10305040


addd x3stod rhalt

????????

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

1011

10pc

90ac

100sp

10099989796959493

…


6


jump main10305090


addd x3stod rhalt

????????

0x1: 1x2: 2x3: 3

r: 4main: 5

6789

1011

11pc

90ac

100sp

10099989796959493

…


7Sem inline eram 21…


Comparação

Sem inline:

jump main # Variáveis: x1 = 10 x2 = 30 x3 = 50 r = 0 # Aqui faz-se a soma:main: lodd x1 # Carrega variável x1 no acumulador. push # Coloca acumulador no topo da pilha. lodd x2 # Carrega variável x2 no acumulador. push # Coloca acumulador no topo da pilha. # Aqui a pilha tem os dois argumentos x1 e x2: call soma # Invoca a função soma. insp 2 # Repõe a pilha (limpeza da casa). # Aqui o acumulador tem o valor devolvido. stod r # Guarda o acumulador na variável r. lodd r # Carrega variável r no acumulador. push # Coloca acumulador no topo da pilha. lodd x3 # Carrega variável x3 no acumulador. push # Coloca acumulador no topo da pilha. # Aqui a pilha tem os dois argumentos r e x3: call soma # Invoca a função soma. insp 2 # Repõe a pilha (limpeza da casa). # Aqui o acumulador tem o valor devolvido. stod r # Guarda o acumulador na variável r. haltsoma: lodl 2 addl 1 retn

Com inline:

jump main # Variáveis: x1 = 10 x2 = 20 x3 = 30 r = 0 # Aqui faz-se a soma:main: lodd x1 # Carrega variável x1 no acumulador. addd x2 # Adiciona variável x2 ao acumulador. stod r # Guarda o acumulador na variável r. lodd r # Carrega variável r no acumulador. addd x3 # Adiciona variável x3 ao acumulador. stod r # Guarda o acumulador na variável r. halt

Sempre mais rápido!

Sempre mais curto?

Não! Por vezes é mais longo. Depende da dimensão do código das rotinas, do número de invocações, etc.

Código demasiado longo pode tornar a execução mais lenta, pois obriga a recorrer à memória virtual.


Sintaxe

Colocar a palavra chave inline antes do cabeçalho na definição da rotina:

inline tipo nome(parâmetros) … { … }

ou

inline tipo Classe::nome(parâmetros) … { … }


Estrutura global do programa (I)



/** 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) {…}


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

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

inline int Racional::numerador() const {…}

inline int Racional::denominador() const {…}

inline Racional::escreve() const {…}


Construtores

Inspectores


Estrutura global do programa (II)



inline Racional& Racional::operator++() {…}

inline Racional& Racional::operator--() {…}

inline Racional& Racional::operator*=(Racional const& r2) {…}

inline Racional& Racional::operator/=(Racional const& r2) {…}

inline Racional& Racional::operator+=(Racional const& r2) {…}

inline Racional& Racional::operator-=(Racional const& r2) {…}

inline void Racional::reduz() {…}

inline bool Racional::cumpreInvariante() const {…}


Modificadores

Auxiliares


Estrutura global do programa (III)


/** Produto de dois racionais. @pre V. @post operator* = r1 × r2. */inline Racional const operator*(Racional r1, Racional const& r2) {…}

/** Divisão de dois racionais. @pre r2 ≠ 0. @post operator/ = r1 / r2. */inline Racional const operator/(Racional r1, Racional const& r2) {…} /** Soma de dois racionais. @pre V. @post operator+ = r1 + r2. */inline Racional const operator+(Racional r1, Racional const& r2) {…}

/** Subtracção de dois racionais. @pre V. @post operator- = r1 - r2. */inline Racional const operator-(Racional r1, Racional const& r2) {…}



não-membro


Estrutura global do programa (IV)



@pre V.

@post operator== = (r1 = r2). */inline bool operator==(Racional const& r1, Racional const& r2) {…} /** Indica se dois racionais são diferentes.

@pre V.

@post operator!= = (r1 ≠ r2). */inline bool operator!=(Racional const& r1, Racional const& r2) {…}

int main() {…}


diferença


Operadores em falta

Aritméticos: Unários: + e -

Relacionais: <, <=, > e >=

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

Inserção e extracção de canais: << e >>

Começamos aqui.

Fica por fazer...


Incrementação prefixa

class Racional { public: …


…

};

Racional& Racional::operator++() { assert(cumpreInvariante());

numerador_ += denominador();

assert(cumpreInvariante());

return *this; }


Incrementação sufixa

?


Incrementação sufixa: a solução

/** Incrementa o racional, devolvendo o seu valor antes de incrementado. @pre r = r. @post operator++ = r r = r + 1. */inline Racional const operator++(Racional& r, int){ Racional const cópia = r; ++r;

return cópia;}

Devolve-se por valor um racional com o valor antes de incrementado, i.e., devolve-se a cópia do racional r.

Faz-se uma cópia de r antes de se incrementar, recorrendo à incrementação prefixa, já definida.

Aha! Cá está a diferença! Trata-se o operador como se fosse binário, recebendo como argumento um inteiro com valor não especificado e irrelevante.


Decrementação sufixa: a solução

/** Decrementa o racional, devolvendo o seu valor antes de decrementado. @pre r = r. @post operator-- = r r = r - 1. */inline Racional const operator--(Racional& r, int){ Racional const cópia = r; --r;

return cópia;}


Operador - unário: operação

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

/** Devolve simétrico do racional. @pre V. @post operator- = -*this. */ Racional const operator-() const;

…

private: …};


Operador - unário: método

inline Racional const Racional::operator-() const{ assert(cumpreInvariante());

Racional r;

r.numerador_ = -numerador(); r.denominador_ = denominador();

assert(r.cumpreInvariante());

return r;}

Não é fundamental usar uma rotina membro, mas permite código mais eficiente, pois pode-se mudar o sinal do numerador directamente, evitando-se invocações espúrias do redutor de fracções.


Operador + unário

/** Devolve o racional. @pre V. @post operator+ ≡ r. */inline Racional const& operator+(Racional const& r){ return r;}


Operador <

/** Devolve verdadeiro se o primeiro racional for menor que o segundo. @pre V. @post operator< = r1 < r2. */inline bool operator<(Racional const& r1, Racional const& r2){ return r1.numerador() * r2.denominador() < r2.numerador() * r1.denominador();}

Como 0 < r1.d 0 < r2.d,

r1.n / r1.d < r2.n / r2.d r1.n x r2.d < r2.n * r1.d


Operadores <=, > e >=

Podem-se definir à custa do operador <

Como?


Operador >

/** Devolve verdadeiro se o primeiro racional for maior que o segundo. @pre V. @post operator> = r1 > r2. */inline bool operator>(Racional const& r1, Racional const& r2){ return r2 < r1;}


Operador <=

/** Devolve verdadeiro se o primeiro racional for menor ou igual ao segundo. @pre V. @post operator<= = r1 <= r2. */inline bool operator<=(Racional const& r1, Racional const& r2){ return not (r1 > r2);}


Operador >=

/** Devolve verdadeiro se o primeiro racional for menor ou igual ao segundo. @pre V. @post operator>= = r1 >= r2. */inline bool operator>=(Racional const& r1, Racional const& r2){ return not (r1 < r2);}


Outro desafio (fácil)

Definir o operador == à custa do operador <


Último problema

Operador /= usa o operador !=, definido mais tarde

Melhor solução: concentrar declarações de rotinas não-membro

após definição da classe Definir rotinas não-membro mais tarde


Preâmbulo e definição da classe C++



/** 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) {…}



Declaração de rotinas não-membro (I)

/** Incrementa o racional, devolvendo o seu valor antes de incrementado.

@pre r = r.

@post operator++ = r r = r + 1. */Racional const operator++(Racional& r, int);

/** Decrementa o racional, devolvendo o seu valor antes de decrementado.

@pre r = r.

@post operator-- = r r = r - 1. */Racional const operator--(Racional& r, int);

Incrementação e decrementação

sufixas


Declaração de rotinas não-membro (II)

/** Produto de dois racionais. @pre V. @post operator* = r1 × r2. */Racional const operator*(Racional r1, Racional const& r2);

/** Divisão de dois racionais. @pre r2 ≠ 0. @post operator/ = r1 / r2. */Racional const operator/(Racional r1, Racional const& r2); /** Soma de dois racionais. @pre V. @post operator+ = r1 + r2. */Racional const operator+(Racional r1, Racional const& r2);

/** Subtracção de dois racionais. @pre V. @post operator- = r1 - r2. */Racional const operator-(Racional r1, Racional const& r2);


binários


Declaração de rotinas não-membro (III)

/** Devolve o racional.

@pre V.

@post operator+ ≡ r. */Racional const& operator+(Racional const& r);


@pre V.

@post operator== = (r1 = r2). */bool operator==(Racional const& r1, Racional const& r2); /** Indica se dois racionais são diferentes.

@pre V.

@post operator!= = (r1 ≠ r2). */bool operator!=(Racional const& r1, Racional const& r2);


diferença

Operador identidade


Declaração de rotinas não-membro (IV)/** Devolve verdadeiro se o primeiro racional for menor que o segundo. @pre V. @post operator< = r1 < r2. */bool operator<(Racional const& r1, Racional const& r2);

/** Devolve verdadeiro se o primeiro racional for maior que o segundo. @pre V. @post operator> = r1 > r2. */bool operator>(Racional const& r1, Racional const& r2);

/** Devolve verdadeiro se o primeiro racional for menor ou igual ao segundo. @pre V. @post operator<= = r1 <= r2. */bool operator<=(Racional const& r1, Racional const& r2);

/** Devolve verdadeiro se o primeiro racional for maior ou igual ao segundo. @pre V. @post operator>= = r1 >= r2. */bool operator>=(Racional const& r1, Racional const& r2);

Operadores relacionais


Definição de métodos (I)

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

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

inline int Racional::numerador() const {…}

inline int Racional::denominador() const {…}

inline void Racional::escreve() const {…}

inline Racional const Racional::operator-() const {…}


inline Racional& Racional::operator++() {…}

inline Racional& Racional::operator--() {…}

inline Racional& Racional::operator*=(Racional const& r2) {…}

inline Racional& Racional::operator/=(Racional const& r2) {…}

inline Racional& Racional::operator+=(Racional const& r2) {…}

inline Racional& Racional::operator-=(Racional const& r2) {…}

inline void Racional::reduz() {…}

inline bool Racional::cumpreInvariante() const {…}


Construtores

Inspectores

Modificadores

Auxiliares


Definição de rotinas não-membro

inline Racional const operator++(Racional& r, int) {…}

inline Racional const operator--(Racional& r, int) {…}

inline Racional const operator*(Racional r1, Racional const& r2) {…}

inline Racional const operator/(Racional r1, Racional const& r2) {…} inline Racional const operator+(Racional r1, Racional const& r2) {…}

inline Racional const operator-(Racional r1, Racional const& r2) {…}

inline Racional const& operator+(Racional const& r) {…}

inline bool operator==(Racional const& r1, Racional const& r2) {…} inline bool operator!=(Racional const& r1, Racional const& r2) {…}

inline bool operator<(Racional const& r1, Racional const& r2) {…}

inline bool operator>(Racional const& r1, Racional const& r2) {…}

inline bool operator<=(Racional const& r1, Racional const& r2) {…}

inline bool operator>=(Racional const& r1, Racional const& r2) {…}

int main() {…}


binários

Incrementação e decrementação

sufixas


diferença

Operador identidade

Operadores relacionais





@pre V.









/** Devolve numerador da fracção mínima correspondente ao racional.

@pre V.

@post numerador/denominador() = *this. */ int numerador() const;

/** Devolve denominador da fracção mínima correspondente ao racional.

@pre V.

@post 0 < denominador (E n : V : n/denominador = *this mdc(n, denominador) = 1). */ int denominador() const;





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

/** Devolve simétrico do racional. @pre V. @post operator- = -*this. */ Racional const operator-() const;




(continuação)(continuação) private: /** Indica se a CIC se verifica. @pre V. @post cumpreInvariante = 0 < denominador_ mdc(numerador_, denominador_) = 1. */ bool cumpreInvariante() const;




Aula 13: Sumário

Definindo constantes de uma classe: Necessidade de declarar operações como constantes (que não alteram a instância

implícita). Sintaxe. Devolução por valor constante. Vantagens da utilização de const.

Evitando o mecanismo de invocação de rotinas no código máquina produzido pelo compilador:

Rotinas inline. Sintaxe. Regras de utilização. Explicação do efeito de inline sobre o código máquina produzido. Exemplo com programa em C++ e respectiva tradução para MAC-1 (ver

Arquitectura de Computadores). Quando optimizar.

Incrementação e decrementação sufixa: sobrecarga. Ordem de declaração/definição de operações/métodos e rotinas não-membro

associados a um TAD.

Aula 13 Tipos Abstractos de Dados IV. 2003/2004 Introdução à Programação 2 Estrutura global do...

Documents

Transcript of Aula 13 Tipos Abstractos de Dados IV. 2003/2004 Introdução à Programação 2 Estrutura global do...