|
|
|
Marco Cantù |
Capítulo 2 |
Antes de proseguir con cómo escribir instrucciones en Pascal, es importante resaltar algunos de elementos del estilo de código de Pascal. La cuestión de la que hablo es la siguiente: aparte de las reglas sintácticas, ¿cómo hay que escribir el código? No hay una respuesta única a esta pregunta, ya que el gusto personal puede dictar distintos estilos. De cualquier manera, hay algunos principios que necesitará saber en relación a comentarios, letras mayúsculas, espacios en blanco y la llamada impresión bonita (pretty-printing). En general, la finalidad de cualquier estilo de codificación es la claridad. Las decisiones que usted toma sobre el estilo y el formato son una especie de taquigrafía que indica la finalidad de una porción de código dada. Una herramienta esencial para la claridad es la coherencia -- sea cual sea el estilo que utilice, asegúrese de seguirlo en todo el proyecto.
En Pascal, los comentarios se encierran bien entre llaves o paréntesis acompañados por un asterisco. Delphi también entiende los comentarios de estilo C++, que se extienden hasta el final de la línea :
{este es un comentario}
(* este es otro comentario *)
// este es un comentario hasta el final de la línea
La primera forma es más breve, y es más común. La segunda forma a menudo se prefiere en Europa, porque muchos teclados europeos carecen del símbolo de llaves. La tercera se tomó prestada de C++, y está disponible sólo en las versiones de Delphi de 32-bits. Los comentarios hasta el final de la línea son muy útiles para comentarios cortos o para evitar que se ejecute una línea (temporalmente).
En los listados de este libro, intentaré marcar los comentarios como cursiva (y palabras clave en negrita), para ser coherente con el resaltado sintáctico por defecto de Delphi.
Que haya tres tipos diferentes de comentarios, puede ser útil para hacer comentarios anidados. Pero si desea evitar que se ejecuten varias líneas de código fuente, y estas líneas contienen algunos comentarios auténticos, no podrá usar el mismo identificador de comentario :
{ ... código
{comentario, que producirá problemas en la ejecución}
... código }
Con un segundo identificador, puede escribir el siguiente código, que es correcto :
{ ... código
//este comentario va bien
... código }
Nótese que si la llave abierta o la cadena paréntesis-asterisco va seguida del signo dólar ($), se convierte en una directiva de compilador, como en {$X+}.
De hecho, directivas de compilador también son comentarios. Por ejemplo, {$X+ Esto es un comentario} es válido. Es a la vez una directiva y un comentario, aunque programadores en su sano juicio probablemente tiendan a separa comentarios y directivas.
El compilador de Pascal (contrariamente a los compiladores de otros lenguajes) no distingue entre mayúsculas y minúsculas. Por tanto, interpreta Minombre, MiNombre, minombre, miNombre y MINOMBRE como exactamente equivalentes. En general, esto es bueno, ya que en otros lenguajes se producen muchos errores por grafía de mayúsculas incorrecta.
Nota: sólo hay una excepción a la equivalencia entre mayúsculas y minúsculas en Pascal: el procedimiento Register de un paquete de componentes debe comenzar con una R mayúscula, por compatibilidad con C++Builder.
Sin embargo, esto conlleva algunas desventajas sutiles. En primer lugar, usted debe ser consciente de que las dos formas de una letra son equivalentes, y no utilizarlas para referirse a elementos distintos. En segundo lugar, debería intentar ser coherente en el uso de mayúsculas y minúsculas, para hacer el código más legible.
Un uso de mayúsculas y minúsculas no es reforzado por el compilador, pero es un buen hábito que se debe adquirir. Una costumbre extendida es poner en mayúsculas sólo la primera letra de los identificadores. Cuando un identificador está formado por varias palabras seguidas (no puede insertar un espacio en un identificador), deberá poner en mayúsculas la primera letra de cada palabra :
MiIdentificadorLargo MiIdentificadorMuyLargoYCasiEstúpido
Otros elementos que el compilador ignorará completamente son los espacios, las líneas nuevas y los espacios de tabulador. A estos elementos se les llama "espacio en blanco" (white space). Un espacio en blanco sólo sirve para hacer el código más legible. No afecta a la compilación.
Al contrario que BASIC, Pascal le deja escribir una instrucción en varias líneas de código, extendiendo una instrucción larga en dos o más líneas. La desventaja (al menos para muchos programadores en BASIC) de permitir esto es que debe acordarse de añadir un punto y coma al final de cada instrucción, o, más exactamente, acordarse de separar las instrucciones entre sí. Dése cuenta de que la única restricción a romper una instrucción es que una cadena de texto debe permanecer en una sola línea.
Tampoco aquí hay reglas fijas para el uso de espacios e instrucciones de varias líneas; sólo algunas reglas básicas :
La última sugerencia sobre el uso de espacios en blanco se refiere al típico estilo de formato en Pascal, llamado "impresión bonita" (pretty-printing). Esta regla es simple: cada vez que necesite escribir una instrucción compuesta, haga una sangría de dos espacios a la derecha del resto de dicha instrucción. Una instrucción compuesta dentro de otra instrucción compuesta llevará una sangría de cuatro espacios, y así sucesivamente :
if ... then instrucción; if ... then begin instrucción1; instrucción2; end; if ... then begin if ... then instrucción1; instrucción2; end;
El formato que se muestra arriba está basado en "impresión bonita", pero los programadores hacen distintas interpretaciones de esta regla general. Algunos sangran las instrucciones begin y end hasta el nivel del código interno; otros sangran estas instrucciones respecto al if ... then y sangran aún más el código interno; también hay programadores que sitúan la instrucción begin en la misma línea de la instrucción if ... then. Esto suele ser cuestión de gusto.
Un formato de sangría similar se usa a menudo para listas de variables o tipos de datos, y para continuar una instrucción que viene de la línea anterior :
type
Letters = set of Char;
var
Name: string;
begin
{ comentario largo e instrucción larga, que sigue en la
línea siguiente y está sangrada dos espacios }
MessageDlg ('Esto es un mensaje',
mtInformation, [mbOk], 0);
Por supuesto, cualquier convención de este tipo es sólo una sugerencia para hacer el código más legible a otros programadores, y es totalmente ignorado por el compilador. He intentado utilizar esta regla de forma coherente en todas las muestras y fragmentos de código en este libro. El código fuente Delphi, los manuales y los ejemplos de ayuda (Help) usar un estilo de formato similar.
Para hacer más fácil el leer y escribir código Pascal, el editor Delphi tiene una cualidad llamada resaltado sintáctico. Dependiendo de la función en Pascal de las palabras que usted introduce a través del editor, son representadas con distintos colores. Por defecto, las palabras clave están en letra negrita; cadenas de texto y comentarios están en color (y a menudo en cursiva), etcétera.
Las palabras reservadas, los comentarios y las cadenas de texto son, probablemente, los elementos que más se benefician de esta cualidad. De un vistazo puede usted localizar un error ortográfico, una cadena no terminada correctamente y determinar la longitud de un comentario de varias líneas.
Puede personalizar el resaltado sintáctico utilizando la página Editor Colors del cuadro de diálogo Environment Options (opciones del entorno) (v. figura 2.1). Si trabaja solo, elija los colores que prefiera. Si colabora estrechamente con otros programadores, deberían ponerse de acuerdo en un esquema de color común. Encuentro realmente difícil trabajar en una computadora con un esquema sintáctico de colores distinto al que estoy acostumbrado.
Figura 2.1: El cuadro de diálogo desde el que se establece el resaltado sintáctico de color.
Nota: En este libro he intentado aplicar un tipo de resaltado a los listados de código fuente. Espero que esto los haga más legibles.
Delphi 3 introdujo una nueva cualidad, relacionada con la edición de código fuente. Como al escribir instrucciones en Pascal a menudo se repite la misma secuencia de palabras clave, Borland ha aportado una nueva cualidad llamada Plantillas de Código (Code Templates). Una Plantilla de Código es simplemente una porción de código relacionada con una abreviatura. Usted escribe la abreviatura, pulsa Ctrl+J, y la porción de código correspondiente aparece completa. Por ejemplo, si usted escribe arrayd y pulsa Ctrl+J, el editor de Delphi expandirá esta abreviatura a :
array [0..] of ;
Como las plantillas predefinidas suelen incluir varias versiones de la misma construcción, la abreviatura suele terminar en una letra que indica de cuál de las versiones se trata. En cualquier caso, también puede escribir sólo las primeras letras de la abreviatura. Por ejemplo, si escribe ar y pulsa Ctrl+J, el editor mostrará un menú local con una lista de las opciones disponibles con una descripción breve, como se ve en la figura 2.2.
Figure 2.2: Selección de Plantillas de Código (Code Templates)
Puede usted personalizar totalmente las plantillas, modificando las existentes, o añadiendo las porciones de código que más use. Si hace esto, dése cuenta de que el texto de una plantilla de código normalmente include el carácter '|' , para indicar a dónde debe saltar el cursor tras la operación, esto es, dónde comenzará usted a escribir para completar el código deseado.
Una vez que haya definido algunos identificadores, puede utilizarlos en instrucciones y en las expresiones que son parte de algunas instrucciones. Pascal ofrece varias instrucciones y expresiones. Ante todo, echemos un vistazo a las palabras clave, las expresiones y los operadores.
Se llama palabras clave (keywords) a todos los identificadores reservados por Object Pascal que tienen un papel en el lenguaje. La ayuda de Delphi distingue entre palabras reservadas y directivas : las palabras reservadas no pueden ser utilizadas como identificadores, mientras que las directivas no deberían ser utilizadas como tales, aunque el compilador las aceptará si se usan así. En la práctica, no debería utilizar ningún tipo de palabras clave como identificadores.
En la Tabla 2.1 puede ver una lista completa de los identificadores que tienen un papel específico en Object Pascal (en Delphi 4), incluyendo palabras clave y otras palabras reservadas.
Tabla 2.1: Palabras clave y otras palabras reservadas en Object Pascal.
|
Palabra clave |
Papel |
|---|---|
| absolute | directiva (variables) |
| abstract | directiva (método) |
| and | operador (booleano) |
| array | tipo |
| as | operador (RTTI) |
| asm | instrucción |
| assembler | retrocompatibilidad (asm) |
| at | instrucción (excepciones) |
| automated | especificador de acceso (clase) |
| begin | marcador de bloque |
| case | instrucción |
| cdecl | convención de llamada a una función |
| class | tipo |
| const | declaración o directiva (parámetros) |
| constructor | método especial |
| contains | operador (conjunto) |
| default | directiva (propiedad) |
| destructor | método especial |
| dispid | especificador dispinterfaz |
| dispinterface | tipo |
| div | operador |
| do | instrucción |
| downto | instrucción (for ... then) |
| dynamic | directiva (método) |
| else | instrucción (if or case) |
| end | marcador de bloque |
| except | instrucción (excepciones) |
| export | retrocompatibilidad (clase) |
| exports | declaración |
| external | directiva (funciones) |
| far | retrocompatibilidad (clase) |
| file | tipo |
| finalization | estructura unitaria |
| finally | instrucción (excepciones) |
| for | instrucción (v. to) |
| forward | directiva de función |
| function | declaración |
| goto | instrucción |
| if | instrucción (v. then) |
| implementation | estructura unitaria |
| implements | directiva (propiedad) |
| in | operador (conjunto) - estructura de proyecto |
| index | directiva (dipinterfaz) |
| inherited | instrucción |
| initialization | estructura unitaria |
| inline | retrocompatibilidad (véase asm) |
| interface | tipo |
| is | operador (RTTI) |
| label | declaración |
| library | estructura de programa |
| message | directiva (método) |
| mod | operador (matemático) |
| name | directiva (función) |
| near | retrocompatibilidad (clase) |
| nil | valor |
| nodefault | directiva (propiedad) |
| not | operador (booleano) |
| object | retrocompatibilidad (clase) |
| of | instrucción (case) |
| on | instrucción (excepciones) |
| or | operador (booleano) |
| out | directiva (parámetros) |
| overload | directiva de función |
| override | directiva de función |
| package | estructura de programa (paquete) |
| packed | directiva (registro) |
| pascal | convención de llamada a una función |
| private | especificador de acceso (clase) |
| procedure | declaración |
| program | estructura de programa |
| property | declaración |
| protected | especificador de acceso (clase) |
| public | especificador de acceso (clase) |
| published | especificador de acceso (clase) |
| raise | instrucción (excepciones) |
| read | especificador de propiedad |
| readonly | especificador de interfaz de envío |
| record | tipo |
| register | convención de llamada a una función |
| reintroduce | directiva de función |
| repeat | instrucción |
| requires | estructura de programa (paquete) |
| resident | directiva (funciones) |
| resourcestring | tipo |
| safecall | convención de llamada a una función |
| set | tipo |
| shl | operador (matemático) |
| shr | operador (matemático) |
| stdcall | convención de llamada a una función |
| stored | directiva (propiedad) |
| string | tipo |
| then | instrucción (v. if) |
| threadvar | declaración |
| to | instrucción (v. for) |
| try | instrucción (excepciones) |
| type | declaración |
| unit | estructura unitaria |
| until | instrucción |
| uses | estructura unitaria |
| var | declaración |
| virtual | directiva (método) |
| while | instrucción |
| with | instrucción |
| write | especificador de propiedad |
| writeonly | especificador de interfaz de envío |
| xor | operador (booleano) |
No hay una regla general para construir expresiones, ya que dependen esencialmente de qué operadores se usan, y Pascal tiene muchos operadores. Hay operadores lógicos, aritméticos, relacionales, de conjuntos y otros. Se pueden utilizar expresiones para determinar el valor que se asigna a una variable para calcular el parámetro de una función o procedimiento, o para probar una condición. Las expresiones pueden incluir también llamadas a funciones. Cada vez que ejecuta una operación sobre el valor de un identificador, más que utilizar el identificador como tal, eso es una expresión.
Las expresiones son comunes a la mayoría de lenguajes de programación. Una expresión es una combinación válida de constantes, variables, valores literales (de caracteres), operadores y resultados de funciones. Las expresiones también pueden ser introducidas en los parámetros de valor de procedimientos y funciones, pero no siempre en los parámetros de referencia (que requieren que se les asigne un valor).
Si alguna vez en su vida ha escrito un programa, ya sabe qué es una expresión. Aquí resaltaré elementos específicos de los operadores de Pascal. Puede ver una lista de los operadores del lenguaje, agrupador por precedencia, en la Tabla 2.1.
Al contrario que la mayoría de los demás lenguajes de programación, los operadores and y or tienen prioridad sobre el operador de relación. Así, si usted escribe a < b and c < d, el compilador intentará hacer la operación and primero, lo que resultará en un error de compilación. Por esta razón, debería encerrar cada una de las expresiones relacionales entre paréntesis : (a < b) and (c < d).
Algunos de los operadores comunes tienen distintos significados junto a diferentes tipos de datos. Por ejemplo, el operador + puede usarse para sumar dos números, concatenar dos cadenas de caracteres, unir dos conjuntos e incluso añadir un offset a un puntero (pointer) PChar. De cualquier manera, no se puede sumar dos caracteres, como sí puede hacerse en C.
Otro operador extraño es div. En Pascal se puede dividir cualesquiera números (reales o enteros) con el operador / , y siempre se obtiene un número real. Si necesita obtener un entero como resultado de la división de dos enteros (ignorando el resto aunque sea distinto de cero), use el operador div.
Tabla 2.2: Operadores en Pascal, agrupados por precedencia
|
Operadores unarios (precedencia máxima) |
|
|---|---|
| @ | Dirección de la variable o función (devuelve un puntero) |
| not | not (negación) booleana o por bits |
|
Operadores multiplicativos o por bits |
|
| * | Multiplicación aritmética o intersección de conjuntos |
| / | División de coma flotante |
| div | División entera |
| mod | Módulo (el resto de la división entera) |
| as | Typecast (moldeador) a prueba de tipos (RTTI) (Permite una conversión de tipo durante la ejecución, con comprobación de tipo previa.) |
| and | and (conjunción) booleana o por bits |
| shl | Bitwise left shift (Permite rotar una cadena de bits hacia la izquierda.) |
| shr | Bitwise right shift (Ídem, hacia la derecha.) |
|
Operadores aditivos |
|
| + | Suma aritmética, unión de conjuntos, concatenación de cadenas, suma de punteros offset |
| - | Resta aritmética, diferencia de conjuntos, resta de punteros offset |
| or | or (disyunción) booleana o por bits |
| xor | xor (disyunción exclusiva) booleana o por bits |
|
Operadores relacionales y de comparación (precedencia mínima) |
|
| = | Comprueba si son iguales |
| <> | Comprueba si no son iguales |
| < | Comprueba si es menor que |
| > | Comprueba si es mayor que |
| <= | Comprueba si es menor o igual que, o si es subconjunto de un conjunto |
| >= | Comprueba si es mayor o igual que, o si es "superconjunto" de un conjunto |
| in | Comprueba si pertenece al conjunto |
| is | Comprueba si es compatible respecto al tipo (otro operador RTTI) |
Los operadores de conjuntos incluyen la unión, (+), la diferencia (-), la intersección (*), comprobación de pertenencia (in), y algunos operadores relacionales. Para añadir un elemento a un conjunto, puede unir el conjunto a otro que ya tenga el elemento que necesita. Aquí hay un ejemplo de Delphi, relacionado con los estilos de fuente :
Style := Style + [fsBold]; Style := Style + [fsBold, fsItalic] - [fsUnderline];
Como alternativa, puede usar los procedimientos normalizados Include y Exclude, que son mucho más eficientes (pero no se pueden utilizar con propiedades de componente del tipo de conjunto, que requieren un parámetro de un único valor):
Include (Style, fsBold);
Ahora que conocemos la estructura básica de un programa en Pascal, estamos preparados para comenzar a comprender su significado en detalle. Comenzaremos explorando la definición de tipos de datos predefinidos y definidos por el usuario. Después, pasaremos a estudiar el uso de palabras clave para formar instrucciones de programación.
© Copyright Marco Cantù, Wintech Italia Srl 1995-99
© Copyright de la traducción, Rafael Barranco-Droege, 2000