Aula 3

Modularização: funções e procedimentos

Modularizar

Arte de identificar claramente que módulos devem existir num sistema

SistemaModular

Sistema Integrado

Vantagens da modularização

Facilita detecção de erros: Simples identificar módulo responsável Reduz tempo gasto na identificação

Permite testar módulos individualmente: Reduz complexidade do teste Permite testar antes de completado o sistema

Permite fazer manutenção do sistema módulo a módulo: Reduz probabilidade de haver consequências imprevistas

Permite desenvolvimento independente dos módulos: Simplifica trabalho em equipa

Permite reutilização dos módulos desenvolvidos

Boa modularização

Módulos têm função única e bem definida

Módulos são coesos

Componentes internos com fortes ligações entre si

Existem poucas ligações entre os componentes internos?

Talvez se deva dividir o módulo…

Ligações entre módulos mínimas:

Existem muitas ligações entre os módulos? Talvez

devam formar um único módulo…

Abstracção

In this connection it might be worthwhile to point out thatthe purpose of abstraction is not to be vague, but to createa new semantic level in which one can be absolutely precise.

Edsger W. Dijkstra, “The Humble Programmer”,Communications of the ACM, 15(10), 1972.

Abstracção

Utilização de sistema olhando apenas para o

seu funcionamento externo

Limita quantidade de informação com que lidar Maior produtividade

Menor taxa de erros

Encapsulamento

Única parte visível é a interface

Mecanismo interno dos módulos encerrado

numa cápsula (caixa preta)

Protege consumidor dos seus erros

Facilita abstracção

Papeis do programador

Programador assume papeis distintos: Produtor

• Desenvolve mecanismo do módulo• Preocupa-se com:

• o que faz• como se usa• como funciona

Consumidor• Integra cada módulo em sistema complexo• Preocupa-se com:

• o que faz• como se usa• como funcionacomo funciona

Contrato

Entre produtor e consumidor

Indica como se usa

Produtor garante resultados…

…se consumidor respeitar condições de

utilização

Módulos em C++

Rotinas Funções

Conjunto de instruções, com interface bem

definida, que efectua um dado cálculo

Procedimentos

Conjunto de instruções, com interface bem

definida, que faz qualquer coisa

Resolução de problemas

Abordagem descendente(top down)

Análise global do problema Identificação de sub-problemas Resolução independentemente de cada

sub-problema usando a mesma abordagem Problemas e sub-problemas correspondem a rotinas

Vantagens Diminuição da informação a processar pelo programador

em cada instante Redução da complexidade dos problemas até à

trivialidade

Problema

Escrever programa para somar duas fracções positivas fornecidas pelo utilizador e mostrar resultado no ecrã na forma de uma fracção irredutível

6/9 + 7/3 = 3/1

Sub-problemas

1. Ler fracções

2. Calcular fracção soma reduzida

3. Escrever resultado

Em C++

#include <iostream> using namespace std;

int main() { // Ler fracções: ... // Calcular fracção soma reduzida: ... // Escrever resultado: ...}

Ler fracções

// Ler fracções:

cout << "Introduza duas fracções (numerador denominador): "; int n1, d1, n2, d2; cin >> n1 >> d1 >> n2 >> d2;

Escrever resultado

// Escrever resultado:

cout << "A soma de "; escreveFracção(n1, d1); cout << " com "; escreveFracção(n2, d2); cout << " é "; escreveFracção(?, ?); cout << '.' << endl;

Calcular fracção soma reduzida

// Calcular fracção soma reduzida

int n;int d;

Calcular fracção soma reduzida

// Calcular fracção soma reduzida

int n = d2 * n1 + d1 * n2;int d = d1 * d2;

Calcular fracção soma reduzida

// Calcular fracção soma reduzida

int n = d2 * n1 + d1 * n2;int d = d1 * d2;int k = mdc(n, d);n /= k;d /= k;

Ler fracções

// Ler fracções: cout << "Introduza duas fracções (numerador denominador): "; int n1, d1, n2, d2; cin >> n1 >> d1 >> n2 >> d2; int k = mdc(n1, d1); n1 /= k; d1 /= k; int k = mdc(n2, d2); n2 /= k; d2 /= k;

Ler fracções

// Ler fracções: cout << "Introduza duas fracções (numerador denominador): "; int n1, d1, n2, d2; cin >> n1 >> d1 >> n2 >> d2; int k = mdc(n1, d1); n1 /= k; d1 /= k; int k = mdc(n2, d2); n2 /= k; d2 /= k;

Calcular fracção soma reduzida

// Calcular fracção soma reduzida

int n = d2 * n1 + d1 * n2;int d = d1 * d2;int k = mdc(n, d);n /= k;d /= k;

Máximo divisor comum (I)

int m; // Inicializadasint n; // automagicamente!

int r;

if(m < n) r = m; else r = n;

while(m % r != 0 or n % r != 0) --r;

m : int

n : int

k : int

Máximo divisor comum (II)

int const m; // Inicializadasint const n; // automagicamente!

int r;

if(m < n) r = m; else r = n;

while(m % r != 0 or n % r != 0) --r;

m : int {frozen}

n : int {frozen}

k : int

Máximo divisor comum (III)

{ int const m; // Inicializadas int const n; // automagicamente!

int r;

if(m < n) r = m; else r = n;

while(m % r != 0 or n % r != 0) --r;}

Encapsular código numa caixa

Máximo divisor comum (IV)

mdc{ int const m; // Inicializadas int const n; // automagicamente!

int r;

if(m < n) r = m; else r = n;

while(m % r != 0 or n % r != 0) --r;}

Nome do módulo

Máximo divisor comum (V)

mdc(int const m, int const n){ int r;

if(m < n) r = m; else r = n;

while(m % r != 0 or n % r != 0) --r;}

Parâmetros: variáveis ou constantes especiais de entrada

Máximo divisor comum (VI)

mdc(int const m, int const n){ int r;

if(m < n) r = m; else r = n;

while(m % r != 0 or n % r != 0) --r;

return r;}

Retorno e devolução: regressa ao ponto onde foi invocada e devolve valor guardado em r

Máximo divisor comum (VII)

int mdc(int const m, int const n){ int r;

if(m < n) r = m; else r = n;

while(m % r != 0 or n % r != 0) --r;

return r;}

Devolução de valor com tipo int

Máximo divisor comum (VIII)

/** Devolve o máximo divisor comum dos inteiros positivos passados como argumento. @pre 0 < m e 0 < n. @post o valor r devolvido é o mdc de m e n. */ int mdc(int const m, int const n){ int r;

if(m < n) r = m; else r = n;

while(m % r != 0 or n % r != 0) --r;

return r;}

Cabeçalho: como se usa

Corpo: como funciona

Documentação: o que faz

Máximo divisor comum (IX)

/** Devolve o máximo divisor comum dos inteiros positivos passados como argumento. @pre 0 < m e 0 < n. @post o valor r devolvido é o mdc de m e n. */ int mdc(int const m, int const n){ assert(0 < m); assert(0 < n);

int r;

if(m < n) r = m; else r = n;

while(m % r != 0 or n % r != 0) --r;

assert(0 < r); assert(m % r == 0); assert(n % r == 0);

return r;}

Instruções de asserção (afirmação)

Escreve fracção

/** Escreve no ecrã uma fracção, no formato usual, que lhe é passada na forma de dois argumentos inteiros positivos. @pre nenhuma. @post o ecrã contém n/d em que n e d são os valores de n e d em base decimal. */void escreveFracção(int const n, int const d){}

Um procedimento não devolve nada: faz qualquer coisa

Escreve fracção

/** Escreve no ecrã uma fracção, no formato usual, que lhe é passada na forma de dois argumentos inteiros positivos. @pre nenhuma. @post o ecrã contém n/d em que n e d são os valores de n e d em base decimal. */void escreveFracção(int const n, int const d){ cout << n << ‘/’ << d;}

Somador de fracções

#include <iostream> using namespace std;

/** … */int mdc(int const m, int const n){ ...}

/** … */void escreveFracção(int const n, int const d){ ...}

int main() { ...}

Aula 3: Sumário

Modularização, abstracção e encapsulamento. Rotinas como unidades atómicas de modularização. Abordagem descendente. Sintaxe da definição de rotinas: cabeçalho vs. corpo. Interface e implementação. Contratos: pré-condições e condições objectivo. Instruções de asserção e programação por contrato. Parâmetros e argumentos. Instrução return. Retorno e devolução. Procedimentos: não há devolução (tipo de devolução void). Invocação de rotinas.