Aula 4 Modularizao funes e procedimentos continuao Somador

Aula 4 Modularização: funções e procedimentos (continuação)

Somador de fracções #include <iostream> using namespace std; /** … */ int mdc(int const m, int const n) {. . . } /** … */ void escreve. Fracção(int const n, int const d) {. . . } int main() {. . . }

Máximo divisor comum /** 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;

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 escreve. Fracção(int const n, int const d) { cout << n; if(d != 1) cout << ‘/’ << d; }

Principal: Ler fracções // Ler fracções: cout << "Introduza duas fracções (numerador denominador): "; int n 1, d 1, n 2, d 2; cin >> n 1 >> d 1 >> n 2 >> d 2; int k = mdc(n 1, d 1); n 1 /= k; d 1 /= k; k = mdc(n 2, d 2); n 2 /= k; d 2 /= k;

Principal: Calcular fracção soma reduzida // Calcular fracção soma reduzida: int n = d 2 * n 1 + d 1 * n 2; int d = d 1 * d 2; k = mdc(n, d); n /= k; d /= k;

Principal: Escrever resultado // Escrever resultado: cout << "A soma de "; escreve. Fracção(n 1, d 1); cout << " com "; escreve. Fracção(n 2, d 2); cout << " é "; escreve. Fracção(n, d); cout << '. ' << endl;

Redução de fracções // Reduz fracção: k = mdc(n, d); n /= k; d /= k;

Módulo reduz. Fracção() /** Reduz a fracção recebida como argumento. @pre 0 < n e 0 < d. @post mdc(n, d) = 1 (e n/d representa o mesmo racional que originalmente). */ void reduz. Fracção(int n, int d) { assert(0 < n); assert(0 < d); int const k = mdc(n, d); n /= k; d /= k; assert(mdc(n, d) == 1); }

Principal: Calcular fracção soma reduzida // Calcular fracção soma reduzida: int n = d 2 * n 1 + d 1 * n 2; int d = d 1 * d 2; reduz. Fracção(n, d);

Principal: Ler fracções // Ler fracções: cout << "Introduza duas fracções (numerador denominador): "; int n 1, d 1, n 2, d 2; cin >> n 1 >> d 1 >> n 2 >> d 2; reduz. Fracção(n 1, d 1); reduz. Fracção(n 2, d 2);

Principal: Ler fracções // Ler fracções: cout << "Introduza duas fracções (numerador denominador): "; int n 1, d 1, n 2, d 2; cin >> n 1 >> d 1 >> n 2 >> d 2; reduz. Fracção(n 1, d 1); reduz. Fracção(n 2, d 2);

Traçado main() n 1 : int ? d 1 : int ?

Traçado main() reduz. Fracção() n : int n 1 : int 6 6 d : int d 1 : int 9 9 k : int {frozen} 3

Traçado main() reduz. Fracção() n : int n 1 : int 2 6 d : int d 1 : int 9 9 k : int {frozen} 3

Traçado main() reduz. Fracção() n : int n 1 : int 2 6 d : int d 1 : int 9 3 k : int {frozen} 3

Traçado main() n 1 : int 6 d 1 : int 9

Passagem por referência ¢ ¢ ¢ Parâmetros são sinónimos de argumentos Argumentos não podem ser literais Parâmetros referências servem de entradas e de saídas

Módulo reduz. Fracção() /** Reduz a fracção recebida como argumento. @pre 0 < n e 0 < d. @post mdc(n, d) = 1 (e n/d representa o mesmo racional que originalmente). */ void reduz. Fracção(int& n, int& d) { assert(0 < n); assert(0 < d); int const k = mdc(n, d); n /= k; d /= k; assert(mdc(n, d) == 1); } Parâmetro é referência!

Principal: Ler fracções // Ler fracções: cout << "Introduza duas fracções (numerador denominador): "; int n 1, d 1, n 2, d 2; cin >> n 1 >> d 1 >> n 2 >> d 2; reduz. Fracção(n 1, d 1); reduz. Fracção(n 2, d 2);

Traçado main() n 1 : int ? d 1 : int ?

Traçado main() reduz. Fracção() n : int& n 1 : int 6 d : int& d 1 : int 9 k : int {frozen} 3

Traçado main() reduz. Fracção() n : int& n 1 : int 2 d : int& d 1 : int 9 k : int {frozen} 3

Traçado main() reduz. Fracção() n : int& n 1 : int 2 d : int& d 1 : int 3 k : int {frozen} 3

Traçado main() reduz. Fracção() n : int& n 1 : int 2 d : int& d 1 : int 3 k : int {frozen} 3

Traçado main() n 1 : int 2 d 1 : int 3

Blocos de instruções mbito e permanência

Bloco de instruções ¢ Bloco de instruções (ou instrução composta): l l Conjunto de instruções agrupadas Funcionam como uma só instrução { // Instruções: . . . }

Exemplo int const j = 1; int main() { // Bloco 1. int i = 2; if(0 < i) { // Bloco 2. int j = i; int const i = 3; cout << i << j << endl; } }

Tipos de instâncias (para já) ¢ Instâncias locais l l ¢ Instâncias globais l l ¢ Definidas dentro de rotinas Pertencem ao contexto do bloco de instruções onde foram definidas Definidas fora das rotinas Pertencem ao contexto global Dentro do mesmo contexto não podem ser definidas duas instâncias com o mesmo nome

Definições erradas int const j = 1; int j = 11; // erro! int main() { int i = 2; int i = 22; // erro! if(0 < i) { int j = i; int const i = 33; // erro! cout << i << ' ' << j << endl; } }

mbito e permanência (I) ¢ mbito l ¢ Instância global l ¢ Zona de programa na qual o nome da instância é visível Visível desde definição até fim do ficheiro Instância local l Visível desde definição até fim do seu bloco, incluindo blocos embutidos

Linhas de visibilidade int const j = 1; int main() { // Bloco 1. int i = 2; if(0 < i) { // Bloco 2. int j = i; int const i = 3; cout << i << j << endl; } }

Ocultação int const j = 1; int main() { // Bloco 1. int i = 2; if(0 < i) { // Bloco 2. int j = i; int const i = 3; cout << i << j << endl; } } Ocultações

mbito e permanência (II) ¢ Permanência l ¢ Instâncias globais l ¢ Do princípio ao fim do programa: estáticas Instâncias locais l ¢ Período de tempo durante o qual a instância existe Desde a execução da definição até saída do bloco: automáticas Diz-se que as instâncias são construídas e destruídas

Principal: Ler fracções // Ler fracções: cout << "Introduza duas fracções (numerador denominador): "; int n 1, d 1, n 2, d 2; cin >> n 1 >> d 1 >> n 2 >> d 2; reduz. Fracção(n 1, d 1); reduz. Fracção(n 2, d 2); int k = mdc(n 1, d 1);

Construção e destruição main() n 1 : int ? d 1 : int ? k : int ?

Construção e destruição main() mdc() n 1 : int m : int {frozen} 6 6 d 1 : int n : int {frozen} 9 9 k : int r : int ? ?

Construção e destruição main() mdc() n 1 : int m : int {frozen} 6 6 d 1 : int n : int {frozen} 9 9 k : int r : int ? 6

Construção e destruição main() mdc() n 1 : int m : int {frozen} 6 6 d 1 : int n : int {frozen} 9 9 k : int r : int ? 5

Construção e destruição main() mdc() n 1 : int m : int {frozen} 6 6 d 1 : int n : int {frozen} 9 9 k : int r : int ? 4

Construção e destruição main() mdc() n 1 : int m : int {frozen} 6 6 d 1 : int n : int {frozen} 9 9 k : int r : int ? 3

Construção e destruição main() n 1 : int 6 d 1 : int 9 k : int 3

Variáveis globais ¢ Vantagens l ¢ Não há!!!!! Desvantagens l l l Rotinas sem significado evidente Alterar nomes das variáveis implica alterar todo o programa Reaproveitamento de código mais difícil

Constantes globais ¢ Muito úteis! #include <iostream> using namespace std; double const π = 3. 14159; double perímetro. De. Circunferência. Com(double const raio) { return 2. 0 * π * raio; } int main() { cout << "Insira o raio: "; double raio; cin >> raio; cout << "Perímetro: “ << perímetro. De. Circunferência. Com(raio ) << endl; cout << “Área: “ << π * raio << endl; }

Constantes globais ¢ Muito úteis! #include <iostream> using namespace std; Double const pi = 3. 14159; double perímetro. De. Circunferência. Com(double const raio) { return 2. 0 * pi * raio; } int main() { cout << "Insira o raio: "; double raio; cin >> raio; cout << "Perímetro: “ << perímetro. De. Circunferência. Com(raio ) << endl; cout << “Área: “ << pi * raio << endl; }

Declarações #include <iostream> using namespace std; Declaração int main() { void escreve. Fracção(int n, int d); void reduz. Fracção(int& n, int& d); . . . } void escreve. Fracção(int const n, int const d) {. . . } void reduz. Fracção(int& n, int& d) { int mdc(int m, int n); . . . } int mdc(int const m, int const n) {. . . } Definição

Nomes ¢ Instâncias l ¢ Instâncias booleanas l ¢ Acção (verbo) no imperativo e complementos Funções l ¢ Afirmação que pode ser verdadeira ou falsa Procedimentos l ¢ Substantivo ou frase substantiva: aquilo que é guardado Substantivo ou frase substantiva: aquilo que é devolvido Funções booleanas ou predicados l Afirmação que pode ser verdadeira ou falsa

Nomes ¢ Instâncias l ¢ Instâncias booleanas l ¢ Este procedimento … Funções l ¢ Esta instância indica se … Procedimentos l ¢ Esta instância guarda … Esta função devolve … Funções booleanas ou predicados l Esta função devolve um valor que indica se …

Grafismo ¢ Instâncias l ¢ Separar palavras com _ Rotinas Não separar palavras l Iniciar palavras excepto primeira com maiúsculas l

Exemplos int número_de_alunos = 20; bool hoje_há_aulas = true; void escreve. Fracção(int const numerador, int const denominador) double quadrado. De(double const valor) bool são. Iguais(char const a, char const b)

Tamanho das rotinas ¢ Ideal l ¢ Normal l ¢ até 10 linhas Em casos extremos l ¢ 1 a 3 linhas até 60 linhas Nunca mais!

Aula 4: Sumário ¢ ¢ ¢ ¢ Passagem de argumentos por valor e referência. Blocos de instruções. Blocos embutidos. Instâncias locais e globais: âmbito, permanência e ocultação. Regra da definição única. Perigos das variáveis globais. Uso de constantes globais. Parâmetros como instâncias locais. Declaração vs. definição. Noções sobre nomes de instâncias, funções e procedimentos. Comprimento típico de rotinas.