Modularização de Programas em C++

Prévia do material em texto

Modularização
Para que?
Para permitir o reaproveitamento de código já construído (por você ou por outros programadores);
Para evitar que um trecho de código que seja repetido várias vezes dentro de um mesmo programa;
Para permitir a alteração de um trecho de código de uma forma mais rápida. Com o uso de uma função é preciso alterar apenas dentro da função que se deseja;
 Para que os blocos do programa não fiquem grandes demais e, por consequência, mais difíceis de entender;
Para facilitar a leitura do programa-fonte de uma forma mais fácil;
Para separar o programa em partes(blocos) que possam ser logicamente compreendidos de forma isolada.
Formato de uma função
tipo_da_funcao NomeDaFuncao (Lista_de_Parametros) {
 // corpo da função
}
#include <cstdlib>
#include <iostream>
using namespace std;
void SOMA(float a, int b) {
float result; 
result = a+b;
cout << " Soma = " << result << " \n”;
}
Qual a relação entre a e b com x e y?
int main() {
int x;
float y;
x = 10;
y = 12.5;
SOMA(y,x);
system ("PAUSE");
return 0
}
#include <cstdlib>
#include <iostream>
using namespace std;
float SOMA(float a, int b) {
 float result; 
 result = a+b;
 return result;
}
O que mudou?
int main() {
 int x;
 float y, r;
 x = 10;
 y = 12.5;
 r = SOMA(y,x);
 cout << "soma = " << r << "\n";
 system ("PAUSE");
 return EXIT_SUCCESS;
}
#include <cstdlib>
#include <iostream>
using namespace std;
float SOMA(float a, int b);
Melhor forma: declarar protótipo
int main() {
 int x;
 float y, r;
 x = 10;
 y = 12.5;
 r = SOMA(y,x);
 cout << "soma = " << r << "\n";
 system ("PAUSE");
 return EXIT_SUCCESS;
}
Jogo da Velha
Jogar
Identificar quem ganhou
Jogo da Velha
Jogar
Desenhar tabuleiro
Até terminar{
Jogada do jogador 1
Jogada do jogador 2
Terminou?
 }
Identificar quem ganhou
int main(void)
{
 int tabuleiro[DIM][DIM], continua;
 IniciaTabuleiro(tabuleiro);
 MostraTabuleiro(tabuleiro);
 vez=1;
 do{
 system("cls");
 MostraTabuleiro(tabuleiro);
 jogada(tabuleiro);
 }while(termino(tabuleiro) != 1);
 system("PAUSE");
 return 0;
}
 
#include <cstdlib>
#include <iostream>
#define DIM 3
using namespace std;
int vez;
void IniciaTabuleiro(int tabuleiro[][DIM]);
void MostraTabuleiro(int tabuleiro[][DIM]);
void jogada(int tabuleiro[][DIM]);
int ValidaPosicao(int tabuleiro[][DIM], int linha, int coluna);
int ValidaLinha(int tabuleiro[][DIM]);
int ValidaColuna(int tabuleiro[][DIM]);
int ValidaDiagonal(int tabuleiro[][DIM]);
int ValidaEmpate(int tabuleiro[][DIM]);
int termino(int tabuleiro[][DIM]);
void IniciaTabuleiro(int tabuleiro[][DIM]) {
 int linha, coluna;
 for(linha = 0 ; linha < DIM ; linha++)
 for(coluna = 0 ; coluna < DIM ; coluna++)
 tabuleiro[linha][coluna] = 0;
}
void MostraTabuleiro(int tabuleiro[][DIM]) {
 int linha, coluna;
 putchar('\n');
 for(linha = 0 ; linha < DIM ; linha++){
 for(coluna = 0 ; coluna < DIM ; coluna++){ 
 if(tabuleiro[linha][coluna] == 0)
 cout <<" ";
 else
 if(tabuleiro[linha][coluna] == 1)
 cout <<" X ";
 else
 cout <<" O ";
 if(coluna != (DIM-1))
 cout <<"|";
 }
 putchar('\n');
 }
 putchar('\n');
}
int ValidaPosicao(int tabuleiro[][DIM], int linha, int coluna)
{
 if(linha < 0 || linha > (DIM-1) || coluna < 0 || coluna > (DIM-1) || tabuleiro[linha][coluna] != 0)
 return 0;
 else
 return 1;
}
Nãos seria melhor ter apenas um “return”? Como fazer?
int ValidaLinha(int tabuleiro[][DIM]){
 int linha, coluna, soma;
 for(linha = 0 ; linha < DIM ; linha++) {
 soma=0;
 for(coluna = 0 ; coluna < DIM ; coluna++)
 soma += tabuleiro[linha][coluna];
 if(soma==DIM || soma == (-1)*DIM)
 return 1;
 }
 return 0;
}
int ValidaColuna(int tabuleiro[][DIM]){
 int linha, coluna, soma;
 for(coluna = 0 ; coluna < DIM ; coluna++) {
 soma=0;
 for(linha = 0 ; linha < DIM ; linha++)
 soma += tabuleiro[linha][coluna];
 if(soma==DIM || soma == (-1)*DIM)
 return 1;
 }
 return 0;
}
int ValidaDiagonal(int tabuleiro[][DIM])
{
 int linha,
 diagonal_principal=0,
 diagonal_secundaria=0;
 
 for(linha = 0 ; linha < DIM ; linha++) {
 diagonal_principal += tabuleiro[linha][linha];
 diagonal_secundaria += tabuleiro[linha][DIM-linha-1];
 }
 if(diagonal_principal==DIM || diagonal_principal==(-1)*DIM ||
 diagonal_secundaria==DIM || diagonal_secundaria==(-1)*DIM)
 return 1;
 return 0;
}
int ValidaEmpate(int tabuleiro[][DIM]) {
 int linha, coluna;
 
 for(linha = 0 ; linha < DIM ; linha++)
 for(coluna = 0 ; coluna < DIM ; coluna++)
 if(tabuleiro[linha][coluna] == 0)
 return 0;
 return 1;
}
int termino(int tabuleiro[][DIM]){
 int fim=0;
 if(ValidaLinha(tabuleiro)) {
 cout <<"Jogo encerrado:"<< (vez%2)+1 << " venceu\n";
 MostraTabuleiro(tabuleiro);
 fim= 1;
 }
 if(ValidaColuna(tabuleiro)) {
 cout <<"Jogo encerrado:"<< (vez%2)+1 << " venceu\n";
 MostraTabuleiro(tabuleiro);
 fim= 1;
 }
 if(ValidaDiagonal(tabuleiro)) {
 cout <<"Jogo encerrado:"<< (vez%2)+1 << " venceu\n";
 MostraTabuleiro(tabuleiro);
 fim= 1;
 }
 
 
 if(ValidaEmpate(tabuleiro)) {
 cout <<"Jogo encerrado. Empate!\n";
 MostraTabuleiro(tabuleiro);
 fim= 1;
 }
 
 return fim;
}
void jogada(int tabuleiro[DIM][DIM]) {
 int linha, coluna;
 vez++;
 cout <<"\nJogador " << (vez % 2) + 1 << "\n";
 do {
 cout <<" Linha: ";
 cin >>linha;
 linha--;
 cout <<" Coluna: ";
 cin >>coluna;
 coluna--;
 if(ValidaPosicao(tabuleiro, linha, coluna) == 0)
 cout <<"Posicao ocupada ou inexistente.\n";
 } while(ValidaPosicao(tabuleiro, linha, coluna) == 0);
 
 if(vez%2)
 tabuleiro[linha][coluna] = -1;
 else
 tabuleiro[linha][coluna] = 1;
}