Invocación al procedimiento en Pascal

Para invocar a un procedimiento, la sintaxis es:

<nombre_de_procedimiento> (parámetros_actuales) ;

donde la existencia de parámetros_actuales dependerá de que en la declaración del procedimiento se hayan utilizado parámetros formales.

Para ejemplificar el uso de procedimientos, diseñaremos un programa que resuelva el problema de SUMAR Y MULTIPLICAR MATRICES.

PSEUDOCODIGO

{PROGRAMA PARA SUMAR Y MULTIPLICAR MATRICES}
INICIO
  IMPRIME encabezado.
  LEE las dimensiones de las matrices A y B.
  SI las matrices no son compatibles para la suma, 
  ENTONCES
    IMPRIME mensaje_1.
  SI las matrices no son compatibles para la mult., 
  ENTONCES
    IMPRIME mensaje_2.
  SI son compatibles para la suma o para la mult. , 
  ENTONCES
    INICIO
      LEE las matrices A y B.
      IMPRIME las matrices A y B.
      SI son compatibles para la suma, ENTONCES
        INICIO
          SUMA las matrices A y B.
          IMPRIMEla matriz resultado C.
        FIN
      SI son compatibles para la multiplicacion, ENTONCES
        INICIO
          MULTIPLICA las matrices A y B.
          IMPRIME la matriz resultado D.
        FIN
    FIN
FIN.

CODIFICACION:

Program Opera_matrices;{Programa para sumar y multiplicar matrices de orden 
  hasta de dim_max por dim_max } UsesCrt;Constdim_max = 10;
Typemat = array [1..dim_max , 1..dim_max] ofreal;
Varmat_a,mat_b,mat_c        : mat;
bandera_suma,bandera_mult:boolean;
ren_a,ren_b,col_a,col_b  :integer;

procedureinicio;
Var contador : integer;
beginClrScr;
  gotoxy(23,2);
  WriteLn('SUMA Y MULTIPLICACION DE MATRICES');
  for contador := 1to 80doWrite('=');
  WriteLnend;

{Lee las dimensiones de las matrices}

procedure dim;
begin
WriteLn('DIMENSIONES DE LA MATRIZ A');
  WriteLn;
  Write('Número de renglones ==> ');
  ReadLn(ren_a);
  Write('Numero de columnas  ==> ');
  ReadLn(col_a);
  WriteLn;
  WriteLn;
  WriteLn('DIMENSIONES DE LA MATRIZ B'); 
  WriteLn;
  Write('Número de renglones ==> ');
  ReadLn(ren_b);
  Write('Número de columnas  ==> ');
  ReadLn(col_b)
end;

{Verifica la compatibilidad para la suma}

procedurecompat_suma(ren_f_a,ren_f_b,col_f_a,col_f_b:integer;
                       Varbandera_f:boolean);
beginif ((ren_f_a <> ren_f_b) or (col_f_a <> col_f_b)) thenbeginWriteLn;
      WriteLn('Las matrices A y B son incompatibles para la suma');
      bandera_f :=falseend elsebandera_f :=true end;

{Verifica la compatibilidad para la multiplicación}

procedurecompat_mult(ren_f_a,ren_f_b,col_f_a,col_f_b:integer;
                      Varbandera_f:boolean);
begin ifcol_f_a <> ren_f_bthenbeginWriteLn;
      WriteLn('Las matrices A y B son icompatibles para la multiplicación'); 
      bandera_f := false endelsebandera_f := trueend;

{Lee una matriz}

procedurelee(nmat:char;Varmat_f:mat;ren_max,col_max:integer);
Varren,col : integer;
beginWriteLn;
  WriteLn('ELEMENTOS DE LA MATRIZ : ',nmat);
  WriteLn;
  forren := 1toren_maxdoforcol := 1tocol_maxdobeginWrite('Elemento [ ',ren,',',col,'] = ');
        ReadLn(mat_f[ren,col])
      endend;

{Suma dos matrices}

proceduresuma( mat_f_a,mat_f_b:mat;Varmat_f_c:mat;
                ren_f, col_f :integer);
Varren,col : integer;
beginWriteLn;
  WriteLn('La suma de A y B es :');
  forren := 1toren_fdoforcol := 1tocol_fdomat_f_c[ren,col] := mat_f_a[ren,col] + mat_f_b[ren,col]
end;

{Multiplica dos matrices}

procedure multiplica( mat_f_a, mat_f_b: mat ;Varmat_f_c : mat ;
                      ren_f_a, col_f_a, col_f_b :integer);
Varren, acol, bcol : integer ;
  acum            : real ;
beginWriteLn;
  WriteLn('El producto de A y B es :');
  forren := 1toren_f_adoforbcol := 1tocol_f_bdobegin acum := 0.0 ;
        foracol := 1tocol_f_adoacum := acum + mat_f_a[ren,acol] * mat_f_b[acol,bcol];
        mat_f_c[ren,bcol] := acum endend;

{Imprime una matriz}

procedureimprime(nmat : char ; mat_f : mat ;
                  ren_f, col_f : integer) ;
Varren, col : integer;
beginWriteLn;
  WriteLn('MATRIZ ',nmat);
  for ren := 1toren_fdoforcol := 1tocol_f dobeginWrite(mat_f[ren,col]:6:1,' ');
        WriteLnend;
  WriteLn;
  Write('Oprima una tecla para continuar..... ');
  ReadKey;
  WriteLnend;

{Módulo Principal}

begininicio;
 dim;
 compat_suma(ren_a,ren_b,col_a,col_b,bandera_suma);
 compat_mult(ren_a,ren_b,col_a,col_b,bandera_mult);
 ifbandera_sumaorbandera_mult  then beginlee('A',mat_a,ren_a,col_a);
     lee('B',mat_b,ren_b,col_b);
     imprime('A',mat_a,ren_a,col_a);
     imprime('B',mat_b,ren_b,col_b);
     if bandera_suma thenbeginsuma(mat_a,mat_b,mat_c,ren_a,col_a);
         imprime('C',mat_c,ren_a,col_b)
       end;
     ifbandera_mult then
       beginmultiplica(mat_a,mat_b,mat_c,ren_a,col_a,col_b);
         imprime('D', mat_c, ren_a, col_b)
       endendend.

Observe que el MÓDULO PRINCIPAL está formado por un bloque de instrucciones que invocan a procedimientos.

Invocación al procedimiento en Pascal

Comparte esto:

Relacionado