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

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}

*this: Racional&

Traçado

Introduza …

main()

r1: Racional

n: int {frozen}

numerador: int

*this: Racional&

Traçado

Introduza …

main()

r1: Racional

n: int {frozen}

numerador: int

denominador: int

*this: Racional&

Traçado

Introduza …

main()

r1: Racional

n: int {frozen}

numerador: int

denominador: int

*this: Racional&

Traçado

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

mdc(numerador, denominador) == 1;}

Introduza …

Racional::cumpreInvariante()

main()

r1: Racional

numerador: int

denominador: int

*this: Racional&

Traçado

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

mdc(numerador, denominador) == 1;}

Introduza …

Racional::cumpreInvariante()

main()

r1: Racional

numerador: int

denominador: int

*this: Racional&

Devolve verdadeiro.

Traçado

Introduza …

main()

r1: Racional

n: int

numerador: int

denominador: int

*this: Racional&

Traçado

Introduza …

main()

r1: Racional

n: int

numerador: int

denominador: int

*this: Racional&

Traçado

(continua)

Introduza …

main()

r1: Racional

numerador: int

denominador: int

r2: Racional

numerador: int

denominador: int

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

d: int

*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

*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

*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

*this: Racional&

r1: Racional

Traçado

main()

r2: Racional

Racional::lê()

n: int

d: int

*this: Racional&

r1: Racional

Traçado

main()

r2: Racional

Racional::lê()

n: int

d: int

*this: 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

Traçado

main()

r2: Racional

Racional::reduz()

*this: Racional&

r1: Racional

divisor: int {frozen}

Ignoram-se asserções, para encurtar.

Traçado

main()

r2: Racional

Racional::reduz()

*this: Racional&

r1: Racional

Traçado

main()

r2: Racional

Racional::reduz()

*this: Racional&

r1: Racional

Traçado

main()

r2: Racional

Racional::reduz()

*this: Racional&

r1: Racional

Traçado

main()

r2: Racional

Racional::lê()

n: int

d: int

*this: Racional&

r1: Racional

Traçado

(continua)

main()

r1: 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

r2: Racional const&

Traçado

r.reduz();

return r; }

main()

r2: Racional

Racional::somaCom()

*this: Racional&

r1: Racional

r2: Racional const&

r: Racional

Traçado

r.reduz();

return r; }

main()

r2: Racional

Racional::somaCom()

*this: Racional&

r1: Racional

r2: Racional const&

r: Racional

Traçado

r.reduz();

return r; }

main()

r2: Racional

Racional::somaCom()

*this: Racional&

r1: Racional

r2: Racional const&

r: Racional

Traçado

r.reduz();

return r; }

main()

r2: Racional

Racional::somaCom()

*this: 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

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;

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

Funcionará?

return v;}

main()

i: int

Funcionará?

return v;}

main()

i: int

incrementa()

v: int&

Funcionará?

return v;}

main()

i: int

incrementa()

v: int&

i: int

Funcionará?

return v;}

main()

incrementa()

v: int&

i: int

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

Funcionará?

return v;}

main()

i: int

Funcionará?

return v;}

main()

i: int

incrementa()

v: int&

Funcionará?

return v;}

main()

i: int

incrementa()

v: int&

Funcionará?

return v;}

main()

i: int

incrementa()

v: int&

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

Funcionará?

return v;}

main()

i: int

Funcionará?

return v;}

main()

i: int

Funcionará?

return v;}

main()

i: int

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

E agora?

return v;}

main()

i: int

E agora?

return v;}

main()

i: int

incrementa()

v: int&

E agora?

return v;}

main()

i: int

incrementa()

v: int&

i: int

E agora?

return v;}

main()

incrementa()

v: int&

i: int

: int&

E agora?

return v;}

main()

i: int

: int&

E agora?

return v;}

main()

i: int

incrementa()

v: int&

: int&

E agora?

return v;}

main()

i: int

incrementa()

v: int&

: int&

i: int

E agora?

return v;}

main()

i: int

incrementa()

v: int&

: int&

E agora?

return v;}

main()

i: int

: int&

E agora?

return v;}

main()

i: int

E agora?

return v;}

main()

i: int

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

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

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

Documents

Tipos de Datos Abstractos

04-XML Schema - Compatibility Modesclab.konkuk.ac.kr/attachments/lecture/4/04-XML_Schema.pdf · 2019-09-23 · Namespace in XML Schema qTarget Namespace ØUsing XML Schema, we can

Tipos abstractos de datos

Conjuntos Abstractos

Linguaggio C++ Struttura di un programma. Struttura proposta #include using namespace std; int main() { … }

מונחה עצמים- תרגול 6 | Destructor, static, inline, friend, namespace

VB.NET – Nutzung von ADO - luis.uni- · PDF fileVB.NET und Datenbanken, 25.01.10 Seite 4 Namespace importieren Mit Hilfe von Imports wird ein Namespace (Namensraum) dem Programm

Linguaggio C++ Struttura di un programma. Struttura proposta #include using namespace std; int main() { … return 0; }

6. Tipos de Datos Abstractos

주니어 개발자도 이해 할 수 있는 Go - Namespace 편

Ejercicios Abstractos u.b.v - Nivelación

簡介 Linux 的 Network Namespace 功能

Tipos de Datos Abstractos

namespace logic

Tipos Abstractos de Datos y Objetos.pdf

Język C# ( 4.0 ) using System; namespace HeWo { class Hello {

DE TRISTURAS ALEGÓRICAS Y AMORES ABSTRACTOS

NOMBRES ABSTRACTOS Y RECATEGORIZACIÓN: SOBRE LOS

Definição Classe Objeto Construtor de Classes Manipulando o objeto Namespace Utilização do namespace Herança Polimorfismo Encapsulamento Propriedades

CATALOGO PINTURAS abstractos