Instrucciones simples, compuestas, y estructuradas

La parte funcional de un programa esta constituida, principalmente, por sus instrucciones; estas instrucciones, también conocidas como sentencias, representan todas las acciones escritas que el programa puede ejecutar en un determinado momento.

Generalmente, las instrucciones nos permiten diseñar los algoritmos necesarios para la resolución de problemas que se presenten en situaciones reales. En el artículo anterior, ya se muestran algunos ejemplos de programas hechos con instrucciones sencillas.

En el lenguaje Pascal, las instrucciones están clasificadas en dos grupos principales: las instrucciones simples y las instrucciones estructuradas.

Figura 1. Diagrama de sintaxis de una instrucción en Pascal.

Una instrucción puede rotularse con una etiqueta, y luego saltar a esa misma instrucción, dentro de ciertos límites, mediante su etiqueta, utilizando la instrucción de salto goto (que estudiaremos más adelante).

Instrucciones simples

Tal como su nombre lo dice, una instrucción simple es aquella que no contiene a ninguna otra instrucción dentro de si misma. Básicamente, en lenguaje Pascal se manejan tres tipos de instrucciones simples: entre éstas tenemos las instrucciones de asignación, las instrucciones de procedimiento, y las instrucciones de salto.

Instrucciones de asignación

Las instrucciones de asignación se utilizan para reemplazar el valor actual de una variable, por otro valor devuelto por una expresión, mediante el operador de asignación (:=). Las instrucciones de asignación también se utilizan para asignar el valor de retorno de una función. La sintaxis para las instrucciones de asignación es la siguiente:

{Referencia de variable} := {Expresión};
{Identificador de función} := {Expresión};

El valor devuelto por la expresión debe mantener compatibilidad con el tipo de dato de la variable, o de la función, a la que se va asignar. Algunos ejemplos de instrucciones de asignación para variables son los siguientes:

X := Y + Z;
Area := 3.1416 * Sqr(R);
Switche := (I >= 1) and (I <= 100);

Instrucciones de procedimientos

Una instrucción de procedimiento, tal como su nombre indica, ejecuta un procedimiento específico mediante su identificador.

Si la declaración del procedimiento a ejecutar contiene parámetros formales, entonces la instrucción que llama al procedimiento debe tener asociada una lista de parámetros en curso. Esta lista debe contener los valores que serán pasados, a los respectivos parámetros formales del procedimiento, al momento de su ejecución. La sintaxis para una instrucción de procedimiento es la siguiente:

{Identificador de Procedimiento} [(Lista de parámetros)];

Cada valor de la lista de parámetros debe estar separado por coma. Observe a continuación, algunos ejemplos de instrucciones de procedimiento:

RegistrarDatos;
Writeln (Nombre, ' ', Apellidos);
Transponer (X, Y, Z);

Instrucciones de salto

Las instrucciones de salto nos permiten transferir la ejecución del programa a otra instrucción marcada por una etiqueta específica. Una instrucción de salto se ejecuta mediante la instrucción goto. La sintaxis para esta instrucción es la siguiente:

Goto {Etiqueta};

Donde: {etiqueta} puede ser una sucesión dígitos del rango de 0 a 9999 o un identificador. Para poder ejecutar un salto de instrucción, primero debe anteponerse una etiqueta en la instrucción a la que queremos saltar, y luego referenciar esa etiqueta en la instrucción goto.

Veamos un ejemplo muy práctico de un programa que utiliza los tres tipos de instrucciones simples que hemos visto:

Program E12_Hipotenusa;
{Funciona en: Free Pascal y Turbo Pascal}

Uses Crt;

{Declaraciones:}

Label 
     L1, L2, L3; {Etiquetas}

Var
     a, b: real; {Catetos A y B}
     h: real;    {Hipotenusa}

{Cuerpo principal:}

Begin

     ClrScr;
     Writeln ('******** CALCULO DE HIPOTENUSA ********');
     Writeln ('Ingrese los catetos a y b del triángulo,');
     Writeln ('pulse enter después de cada entrada:');
     Read (a, b);
     h := Sqrt(Sqr(a) + Sqr(b)); {Calcula la hipotenusa}
     Goto L2;

L1:  Write ('Pulse una tecla para salir');
     Goto L3;

L2:  Writeln ('Lados del Triángulo');
     Writeln ('Cateto A   : ', a:10:2);
     Writeln ('Cateto B   : ', b:10:2);
     Writeln ('Hipotenusa : ', h:10:2);
     Writeln ('---------------------------------------');
     Goto L1;

L3:  Readkey

End.

Al momento de utilizar las instrucciones de salto, se debe tener siempre en cuenta las siguientes reglas:

• Las etiquetas primero deben ser declaradas en la sesión de declaraciones, mediante la instrucción label (vea el programa de ejemplo E12_Hipotenusa).
• La instrucción marcada por una etiqueta de salto debe estar en el mismo bloque donde se encuentre la instrucción goto. No es posible saltar una instrucción hacia dentro o hacia fuera de un procedimiento o función.
• Saltar al interior de una instrucción estructurada desde su exterior (es decir, saltar muy adentro de su anidamiento) puede tener efectos indefinidos, aunque el compilador no arroje ningún error. Así por ejemplo, se debe evitar saltar justo dentro de un bucle For.

Importante: desde hace tiempo, las instrucciones de salto han sido las más controvertidas por diversos aspectos. Uno de ellos, por ejemplo, es que si se utilizan con mucha frecuencia, se estará saltando de una parte a otra haciendo difícil seguir el flujo de ejecución. Un programa que utilice un número excesivo de saltos, al cabo de un tiempo, será difícil de entender y de hacerle mantenimiento. Es por ello, que las normas de la programación recomiendan que las instrucciones de salto se utilicen lo menos posible.

Instrucciones compuestas

Las instrucciones compuestas son la combinación de varias instrucciones simples, y que están delimitadas entre las palabras reservadas Begin y End. Una instrucción compuesta, constituye un bloque de instrucciones conjuntas que se ejecutan secuencialmente. Toda instrucción compuesta es tratada como si fuera una sola unidad, sobre todo, en aquellos casos donde únicamente se admite una sola instrucción, tal como en la sentencia If… else.

A continuación observe un ejemplo típico de una instrucción compuesta:

Begin
   A := X + 1;
   B := Y + 2;
   C := Z + 3;
End;

Dentro de una instrucción compuesta, cada instrucción simple que la compone se separa por punto y coma; excepto la última que, aunque está permitido, no requiere colocarle punto y coma. Cada instrucción compuesta también debe separarse, de otras instrucciones externas, mediante un punto y coma después de la palabra end.

Realmente, las instrucciones compuestas forman parte del grupo de instrucciones estructuradas (que se describen en el siguiente apartado); pero, por ser comparativamente lo opuesto a las instrucciones simples, resulta conveniente adelantar su estudio.

Instrucciones estructuradas

Para diseñar programas que ejecuten tareas más difíciles, es necesario combinar instrucciones simples con otras instrucciones especiales, para así producir acciones más complejas. A esa combinación de instrucciones se le suele denominar como instrucciones estructuradas; que son también conocidas como estructuras lógicas.

Figura 2. Diagrama de sintaxis de una instrucción estructurada.

Las instrucciones estructuradas son, por lo tanto, composiciones de instrucciones que pueden ser ejecutadas de forma secuencial, de forma condicional, o de forma repetitiva. En el lenguaje Pascal, existen cuatro tipos de instrucciones estructuradas: instrucciones compuestas, instrucciones condicionales, instrucciones repetitivas, y la instrucción with.

Puesto que las instrucciones estructuradas son un tema muy extenso, serán explicadas en tres partes, en los próximos artículos que se publiquen.