---

            Uma das técnicas mais utilizadas e vantajosas no desenvolvimento de programas é a modularização, que consiste em dividir um programa em diversos módulos de certa forma independentes uns dos outros. Sendo assim existe um módulo principal (programa principal) que chama os outros módulos  e assim os módulos podem chamar outros módulos ou até a si mesmos. Estes módulos são chamados de subprogramas que se dividem em procedimentos e funções.

• PROCEDIMENTO:  possui um cabeçalho de identificação com o nome do procedimento,  um bloco de declarações locais (são declarações que serão definidas dentro do próprio subprograma e só podem ser utilizadas por ele mesmo) e um bloco de comandos. O procedimento pode ser ativado pelo programa principal, ou por um outro procedimento ou função, ou até por ele mesmo.

   begin
      bloco de comandos;
   end;

OBS:- Tudo o que for declarado dentro do procedimento só será reconhecido dentro dele mesmo ==> conceito de variáveis locais.

Exemplo1: O exemplo abaixo calcula a soma de dois números utilizando o conceito de procedimentos.

Program ex_procedure;
uses crt;
var x,y:real;    {variáveis globais }

Procedure tela;
     Begin
        Clrscr;
        Gotoxy(10,8);  write(‘Entre com 1º número =’);
        Gotoxy(10,10);write(‘Entre com 2º número =’);
        Gotoxy(10,12);write(‘Soma                        =’);
    End;
 

Procedure Início;
var som:real;  {variáveis locais}
     Begin
        Tela;
        Gotoxy(50,8);readln(x);
        Gotoxy(50,10;readln(y);
        som:=x+y;
        gotoxy(50,12);write(som:10:2);
        gotoxy(20,24);write(‘Tecle algo para sair’);
        Readkey;
     End;

Begin   { programa principal}
    início;
end.

Outra forma de resolver o mesmo exercício:-

Program ex_procedure;
uses crt;
var x,y:real;    {variáveis globais }

Procedure Soma;
Var som:real; { variável local}
    Begin
        som:=x+y;
        gotoxy(50,12);write(som:10:2);
    End;

Procedure tela;
    Begin
        Clrscr;
        Gotoxy(10,8);  write(‘Entre com 1º número =’);
        Gotoxy(10,10);write(‘Entre com 2º número =’);
        Gotoxy(10,12);write(‘Soma                        =’);
    End;
 

Procedure Início;
     Begin
         Tela;
         Gotoxy(50,8);readln(x);
         Gotoxy(50,10;readln(y);
         Soma;
         gotoxy(20,24);write(‘Tecle algo para sair’);
         Readkey;
     End;

   Begin   { programa principal}
      início;
   end.

O mesmo exercício com estrutura de repetição:-

Program ex_procedure;
uses crt;
var x,y:real;    {variáveis globais }
      op:char;

Procedure Soma;
Var som:real; { variável local}
     Begin
       som:=x+y;
       gotoxy(50,12);write(som:10:2);
     End;

Procedure tela;
     Begin
        Clrscr;
        Gotoxy(10,8);  write(‘Entre com 1º número =’);
        Gotoxy(10,10);write(‘Entre com 2º número =’);
        Gotoxy(10,12);write(‘Soma                        =’);
     End;
 

Procedure Início;
     Begin
         Tela;
         Gotoxy(50,8);readln(x);
         Gotoxy(50,10;readln(y);
         Soma;
         gotoxy(20,24);write(‘Tecle algo para sair’);
         Readkey;
     End;

   Begin   { programa principal}
      repeat
         início;
         gotoxy(40,20);write(‘Deseja Continuar S/N ? ‘);
         repeat
            gotoxy(64,20);clreol;readln(op);
           op:=upcase(op);
         until (op=’S’) or (op=’N’);
      until op=’N’;
   end.
 
 

Exemplo2:  O programa abaixo faz a ordenação de dois números diferentes.

 Program  ordena_num;
  uses crt;

Procedure tela;
    Begin
        Clrscr;
        gotoxy(25,3);write( ‘ **** O R D E N A C A O ****’);
        gotoxy(15,6);write( ‘Entre com o 1º número ........’);
        gotoxy(15,8);write( ‘Entre com o 2º número ........’);
        gotoxy(15,12);write(‘Os números ordenados  ? ‘);
        gotoxy(20,23);write(‘Tecle zero para parar o processo !!’);
        window(50,6,70,12);
    end;
 

Procedure ordena;
var  aux,a,b:integer;    { variáveis locais}
  Begin
      repeat
         gotoxy(1,1);readln(a);
         gotoxy(1,3);readln(b);
         if (a<>0) e (b<>0) then
         begin
            if (a > b) then
               begin
                  aux:=a;
                  a:=b;
                  b:=aux;
               end;
            gotoxy(1,7);write(a,’  ‘, b);
            delay(2000);
            clrscr;
         end;
       until (a=0) or (b=0);
  end;

  Begin  { programa principal}
     Tela;
     Ordena;
  end.
 
 
 

• FUNÇÕES:  As funções são muito parecidas com os procedimentos . A principal diferença é que a função sempre retorna uma informação para o local onde a função foi chamada.

Exemplo:- O exemplo a seguir efetua a soma de dois valores utilizando o conceito de funções.

Program ex_function;
uses crt;
var x,y:real;   {variáveis globais}

Procedure tela;
   Begin
      Clrscr;
      gotoxy(10,8);write(‘Entre com o 1º valor=‘);
      gotoxy(10,10);write(‘Entre com o 2º valor =‘);
      gotoxy(10,12);write(‘A soma = ‘);
   end;
 

Function soma:real;
   begin
       soma:=x+y;
   end;

Procedure início;
   Begin
      Tela;
      gotoxy(50,8);readln(x);
      gotoxy(50,10);readln(y);
      gotoxy(50,12);write(soma:10:2);
      gotoxy(20,25);write(‘tecle algo para terminar’);
      readkey;
   end;

   begin
       início;
   end.
 

O mesmo exemplo utilizando estrutura de repetição:-

Program ex_function;
uses crt;
var x,y:real;   {variáveis globais}

Procedure tela;
   Begin
      Clrscr;
      gotoxy(10,8);write(‘Entre com o 1º valor=‘);
      gotoxy(10,10);write(‘Entre com o 2º valor =‘);
      gotoxy(10,12);write(‘A soma = ‘);
   end;
 

Function soma:real;
   begin
       soma:=x+y;
   end;

Procedure início;
Var op:char;
   Begin
      repeat
         Tela;
         gotoxy(50,8);readln(x);
         gotoxy(50,10);readln(y);
         gotoxy(50,12);write(soma:10:2);
         gotoxy(20,25);write(‘Deseja Continuar <S/N> ?’);
         repeat
             gotoxy(45,25);clreol;readln(op);
             op:=upcase(op);
         until (op=’S’) or (op=’N’);
      until op=’N’;
   end;

   begin
      início;
   end.
 
 

- SUBPROGRAMAS COM PASSAGEM DE PARÂMETROS OU ARGUMENTOS
 

            Os procedimentos e as funções também podem receber ou retornar  valores  e ou variáveis quando ativados. Estes valores ou variáveis são chamados de parâmetros ou argumentos.

Sintaxe:    Procedure identificador (parm1,...,parmn:tipoparam);
                                declaração dos objetos locais:  - constantes
                                                                                tipos
                                                                                variáveis
                                begin
                                        bloco de comandos;
                                end;
 

Sintaxe:    Function identificador (parm1,...,parmn:tipoparam):tipo;
                                declaração dos objetos locais:  - constantes
                                                                                tipos
                                                                                variáveis
                                begin
                                        bloco de comandos;
                                end;
 
 

- PASSAGEM DE PARÂMETROS POR VALOR: No instante da chamada do procedimento ou da função é feita uma cópia dos dados  como se fossem variáveis locais. As informações recebidas podem ser utilizadas pelo procedimento mas as alterações não irão modificar a informação original do local da chamada.

Exemplo1:- O programa abaixo calcula a média aritmética de três provas e verifica a situação do aluno.

                        Program  Ex_proc_valor;
                        uses crt;

                        Procedure media(n1,n2,n3:real);  {passagem de parâmetros por valor}
                        var m:real; sit:string[30];
                        begin
                                m:=(n1+n2+n3)/3;
                                if m >= 5 then sit:=‘apr’
                                               else  sit:=‘rep’;
                                gotoxy(10,12);write(‘Media= ‘,m:5:2);
                                gotoxy(10,14);write(‘Situacao do aluno= ‘,sit);
                                gotoxy(20,24);write(‘Tecle algo’);
                                readkey;
                        end;

                        Procedure tela;
                        Begin
                                Clrscr;
                                gotoxy(10,4);write(‘Registro Acadêmico = ‘);
                                gotoxy(10,6);write(‘1ª nota = ‘);
                                gotoxy(10,8);write(‘2ª nota = ‘);
                                gotoxy(10,10);write(‘3ª nota = ‘);
                        end;

                        Procedure entrada;
                        var p1,p2,p3:Real;   {variáveis locais}
                                         ra:string[9];
                        begin
                                repeat
                                        tela;
                                        gotoxy(32,4);readln(ra);
                                        if ra<> ‘’ then
                                            begin
                                                    gotoxy(32,6);readln(p1);
                                                    gotoxy(32,8);readln(p2);
                                                    gotoxy(32,10);readln(p3);
                                                    media(p1,p2,p3);
                                            end;
                                until ra=’’;
                        end;

                        Begin
                            entrada;
                         End.

Exemplo2: O programa calcula a potência de  um número dado.

Program ex_2;
uses crt;

Procedure Tela;
   begin
         clrscr;
         gotoxy(10,6);write(‘Digite o valor de x = ‘);
         gotoxy(10,8);write(‘X2  = ‘);
         gotoxy(10,10);write(‘X3 = ‘);
         gotoxy(10,12);write(‘X4  = ‘);
   end;

Function potencia (base:real;expoente:integer):real;
var  k:integer;
       p:real;        { variáveis locais}
   begin
         if expoente = 0 then potencia:=1
             else if base=0 then potencia:=0
                 else
                     begin
                             p:=base;
                             for k:=1 to expoente-1 do
                              p:=p*base;
                              potencia:=p;
                     end;
   end;

Procedure entrada;
var x:real;     {variável local}
   begin
         gotoxy(32,6);readln(x);
         gotoxy(15,8);  write(potencia(x,2):15:4);
         gotoxy(15,10);write(potencia(x,3):15:4);
         gotoxy(15,12);write(potencia(x,4):15:4);
         gotoxy(15,20);write(‘Tecle <enter> para terminar >’);
         repeat until  keypressed;
   end;

  Begin     {programa principal}
     tela;
     entrada;
  end.

Exemplo3:-
Program areas_de_figuras;
uses crt;

Procedure tela1;
var k:byte;
    begin
           clrscr;
           gotoxy(26,4); write('AREA DE FIGURAS GEOMETRICAS');
           window(25,8,55,25);
           textbackground(15);textcolor(1);clrscr;
    end;

Procedure tela2;
   begin
         clrscr;
         gotoxy(8,3); write('1. CIRCUNFERENCIA');
         gotoxy(8,5); write('2. TRIANGULO');
         gotoxy(8,7); write('3. FIM DE PROGRAMA');
         gotoxy(8,13); write('DIGITE SUA OPCAO:');
   end;

Function entrada(col,lin:byte):real;
var valor: real;
   BEGIN
       repeat
          gotoxy(col,Lin); clreol; readln(valor);
       until valor>0;
       entrada:=valor;
   end;

Procedure menu;
var opcao:byte;
    area,a,b:real;
   begin
        repeat
           tela2;
            repeat
                gotoxy(25,13); clreol; readkn(opcao);
            until opcao in [1..3];
             if opcao<>3 then
                 begin
                    clrscr;
                    case opcao of
                          1: begin
                                 gotoxy(8,1); write('CIRCUNFERENCIA');
                                 gotoxy(8,4); write('PI: ',PI:5:3);
                                 gotoxy(8,6); write('RAIO:');
                                 area:= pi*sqr(entrada(13,6));
                             end;
                          2: begin
                                 gotoxy(8,1); write('TRIANGULO');
                                 gotoxy(8,4); write('BASE:');b=entrada(13,4);
                                 gotoxy(8,6); write('ALTURA:');a:=entrada(15,6);
                                 area:= (b*a)/2;
                             end;
                      end;
                    gotoxy(8,12); write('AREA: ',area:5:2);
                    gotoxy(15,17);write('TECLE ALGO !!');
                    repeat until readkey<>#0;
                 end;
        until opcao=3;
end;

Begin               {programa principal}
   tela1;
   menu;
   textbackground(0);textcolor(15);clrscr;
End.
 

- PASSAGEM DE PARÂMETROS POR REFERÊNCIA: É utilizado quando precisamos efetuar modificações nos dados recebidos e enviar os resultados para serem utilizados por outro procedimento ou função. Os procedimentos podem receber e ou retornar quantas  informações forem desejadas enquanto que as funções apenas utilizam passagem de parâmetros por valor, pois o nome da função já funciona como se fosse um parâmetro por referência retornando sempre uma única informação.

Exemplo:
Programa Ex_proc_referenc;
uses crt;
type str=string[3];  { para enviar por parâmetro uma informação  string[ ]}

Procedure media(n1,n2,n3:real;var m:Real;var sit:str);
    begin
         m:=(n1+n2+n3)/3;
         if m >= 5 then sit:=‘apr’
            else  sit:=‘rep’;
    end;

Procedure tela;
  Begin
       Clrscr;
       gotoxy(10,4);write(‘1ª nota = ‘);
       gotoxy(10,6);write(‘2ª nota = ‘);
       gotoxy(10,8);write(‘3ª nota = ‘);
       gotoxy(10,10);write(‘Media = ‘);
       gotoxy(10,12);write(‘Situaçao do aluno = ‘);
       repeat until keypressed;
  end;

Procedure entrada;
var p1,p2,p3,m:Real;
                    sit:str;
  begin
        tela;
        gotoxy(30,4);readln(p1);
        gotoxy(30,6);readln(p2);
        gotoxy(30,8);readln(p3);
        media(p1,p2,p3,m,sit);   {as variáveis m e sit  irão retornar  }
        gotoxy(30,10);write(m:5:2);
        gotoxy(30,12);write(sit);
        gotoxy(20,22);write(‘Tecle algo para sair’);
        repeat until keypressed;
  end;

  Begin
     entrada;
  End.
 

OBS:- A declaração FORWARD indica ao compilador que determinado procedimento ou função está definido mais a frente, isto é, não está definido na ordem de sua chamada.
 

-DIRETIVA DE COMPILAÇÃO { $I+} - CHECAGEM DE ENTRADA/SAÍDA

            Sintaxe  {$I+} ou {$I-}
            Default  {$I+}

            Esta diretiva de checagem pode habilitar ou inibir erros de execução de um programa a cada entrada e ou saída, seja qual for o dispositivo utilizado.
            Caso a diretiva esteja habilitada {$i+} e houver um erro na rotina de entrada e ou saída, o programa será interrompido com a respectiva mensagem de erro. Ao contrário se estiver inibida {$I-} , o retorno do erro será enviado a uma função chamada IORESULT, e poderá ser tratado logicamente pelo programador.

Exemplo utilizando um trecho de programa:
         ......
         var t:array[1..10] of integer;
         begin
            {$I-}    { desativa a diretiva de I/O}
             repeat
                    gotoxy(-,-);clreol;readln(t[i]);
             until ioresult=0;
           {$I+}    {ativa a diretiva novamente}
         .....
OBS:- Desta forma a entrada de dados será verificada sendo aceito apenas valores inteiros.