Programação Modular

Prévia do material em texto

PROGRAMAÇÃO MODULAR
Objetivos: 
A programação modular é uma técnica de programação que tem por objetivo simplificar o desenvolvimento de programas através de sua divisão em “partes”.
	Cada uma dessas “partes” pode ser mais facilmente entendida, programada, testada e modificada, pois o problema que está sendo resolvido é menor.
Um algoritmo não modular
	Em um algoritmo que não utiliza os conceitos de programação modular, é importante destacar:
“Partes” de programa são escritas mais de uma vez.
O algoritmo, está dentro das “normas” estabelecidas pela programação estruturada.
Exemplo: um algoritmo que lê um vetor unidimensional de 10 elementos e, em seguida, lê vários vetores de 10 elementos cada. Para cada vetor lido, mostra cada elemento que possui conteúdo idêntico ao do elemento que está na mesma posição no 1º, vetor. O fim dos vetores é indicado por um vetor no qual a soma dos seus três primeiros elementos é igual a 30.
INICIO
	vez ( 1;
	ENQUANTO (vez <= 10)
 	 INICIO
		LEIA primeiro[vez]
 		Vez ( vez + 1
 FIM_ENQUANTO
	vez ( 1;
	ENQUANTO (vez <= 10)
 	 INICIO
		LEIA outro{vez]
 		Vez ( vez + 1
 FIM_ENQUANTO
	Soma ( outro[1] + outro[2] + outro[3]
	ENQUANTO(soma <> 10)
	 INICIO
		vez ( 1;
		ENQUANTO (vez <= 10)
 	 INICIO
			LEIA outro{vez]
 			Vez ( vez + 1
 	 FIM_ENQUANTO
 FIM_ENQUANTO
	
 FIM_ENQUANTO
FIM
Escrevendo Várias Funções no mesmo Programa
Você pode escrever quantas funções quiser em um programa, e qualquer função pode chamar uma outra. Em C++, não é permitido definir uma função dentro de outra função.
Por exemplo, vamos fazer um programa que imprima o texto e a moldura centralizados nas linhas do vídeo.
A saída então, tem o seguinte layout:
**********************
 * FELIZ ANIVERSARIO * 
**********************
#include <cstdlib>
#include <iostream>
using namespace std;
void linha(int n); //prototipo
void espacos(int n);
int main(int argc, char *argv[])
{
 cout << '\n';
 espacos(30);
 linha(21);
 cout << endl;
 espacos(30);
 cout << "* FELIZ ANIVERSARIO *" << endl;
 espacos(30);
 linha(21);
 cout << '\n' << endl;
 
 system("PAUSE");
 return EXIT_SUCCESS;
}
//funcao linha()
//Desenha uma linha de asteriscos na tela
void linha (int n)
{
 for (int i = 0; i < n; i++)
 {
 cout << '*';
 }
}
//funcao espacos()
//Imprime espacos em branco
void espacos (int n)
{
 for (int i = 0; i < n; i++)
 {
 cout << ' ';
 }
}
Chamadas de Funções usadas como argumentos de outras Funções
Você já sabe que a chamada a uma função pode ser utilizada em uma expressão da mesma forma que usamos valores numéricos. Podemos utilizar a chamada a uma função como argumento para outra função.
O próximo exemplo calcula a soma dos quadrados de dois números fornecidos pelo usuário:
#include <cstdlib>
#include <iostream>
using namespace std;
float somasqr (float m, float n);;//prototipo
float sqr (float z); //prototipo
float soma(float m, float n);//protótipo
int main(int argc, char *argv[])
{
 float a, b;
 cout << "\nDigite dois numeros, não inteiros: ";
 cin >> a >> b;
 cout <<"\nA soma dos quadrados eh: " << somasqr(a,b);
 cout << '\n';
 cout << endl;
 
 system("PAUSE");
 return EXIT_SUCCESS;
}
//somasqr()
//Calcula a soma dos quadrados de dois umeros
float somasqr(float m, float n)
{
 return soma(sqr(m), sqr(n));
}
//sqr()
//Calcula o quadrado de um numero
float sqr(float z)
{
 return z * z;
}
//soma()
//Calcula a soma de dois números
float soma (float m, float n)
{
 return m + n;
}
O Operador Unário de Referência
	Com o operador de referência podemos montar novos tipos de dados chamados de referências. Referência é um outro nome para uma variável já existente. As instruções: 
int n;
int& A = n;
informam que A é um outro nome para n. Toda operação em qualquer um dos nomes tem o mesmo resultado. A referência não é uma cópia da variável a que se refere, é a mesma variável sob nomes diferentes. As instruções:
int n;
int& A = n;
n = 5;
cout << A;
A = 8;
cout << n
Imprimem 5 e 8.
O operador unário &, quando usado na criação de referências, faz parte do tipo
int&	é um tipo de dado.
Toda referência deve obrigatoriamente ser inicializada.
int n; 
int& A; //Errado
int& A = n; //Correto
Passagem por Referência
	Um dos usos de referências é na passagem de argumentos para funções. Os exemplos vistos até o momento passam argumentos por valor. Quando argumentos são passados por valor, a função chamada cria variáveis e copia nelas o valor dos argumentos passados. Dessa forma, a função não tem acesso às variáveis originais da função que chamou; portanto, ela não poderá efetuar qualquer modificação nelas.
	A principal vantagem da passagem por referência é a de que a função pode acessar as variáveis da função que chamou. Esse mecanismo possibilita que uma função retorne mais de um valor para a função que chama. Os valores a ser retornados são colocados em referências de variáveis da função chamadora. 
	O próximo exemplo, mostra o uso simples de referência como argumento de uma função.
//Mostra a passagem de argumentos por referência
#include <cstdlib>
#include <iostream>
#include <iomanip>
using namespace std;
void reajusta20(float& p, float& r);//prototipo
int main(int argc, char *argv[])
{
 float preco, valReajustado;
 do
 {
 
 cout <<"\nInsira o preco atual ou 0 para terminar: ";
 cin >> preco;
 reajusta20(preco,valReajustado);
 cout << setprecision(2) 
 << setiosflags(ios::showpoint);
 cout << "\nPreco novo = " << setw(4) << preco << endl;
 cout << "\nAumento = " << setw(4) <<valReajustado << endl; 
 }while (preco != 0.0);
 
 system("PAUSE");
 return EXIT_SUCCESS;
}
//reajusta20()
//Reajusta o preco em 20%
void reajusta20(float& p, float& r)
{
 r = p * 0.2;
 p = p * 1.2;
} 
O programa solicita que o usuário insira o preço atual de uma mercadoria, modifica o preço para um valor reajustado em 20% e calcula o valor do aumento.
Observe que a função reajusta20() poderia encontrar o novo preço e o valor do reajuste sem usar referências, mas como essas informações seriam passadas para main()? Pelo comando return só é possível retornar um valor, mas não dois. 
Funções que recebem argumentos por referência, utilizam o operador & somente na definição do tipo do argumento. 
Observe que a chamada a uma função que recebe uma referência é idêntica à chamada às funções em que os argumentos são passados por valor. 
A declaração
				float& p, float& r
indica que p e r são outros nomes para as variáveis passadas como argumentos pela função que chama. Em outras palavras, quando usamos p e r, na realidade usamos preco e valReajustado de main(); 
Referências não existem em linguagem C, apenas em C++. Em linguagem C passamos argumentos por referência usando ponteiros.