¡Descarga Cursos para Programar en Pascal y más Apuntes en PDF de Informática solo en Docsity!
Curso de Pascal
Versión de libre distribución 2.57h (formato HTML) Nacho Cabanes, Mar. 2000
Curso de Pascal. Temas básicos.
El hecho de llamarlos "temas básicos" no necesariamente quiere decir que sean temas sencillos, sino que son lo que inicialmente se consideró temario del curso. Por otra parte, las "ampliaciones" surgieron después, pero eso no quiere decir que éstas sean más difíciles.
Los temas básicos son los siguientes:
- Tema 0. Introducción - Sobre el curso.
- Tema 1. Generalidades.
- Tema 2. Introd. a variables.
- Tema 3. Entrada/Salida básica.
- Tema 4. Operaciones matemáticas.
- Tema 5. Condiciones.
- Tema 6. Bucles.
- Tema 7. Constantes y tipos.
- Tema 8. Procedimientos y funciones.
- Tema 9. Otros tipos de datos. Temas casi exclusivos de Turbo Pascal.
- Tema 10. Pantalla en modo texto.
- Tema 11. Ficheros.
- Tema 12. Creación de unidades.
- Tema 13. Variables dinámicas.
- Tema 14. Creación de gráficos.
- Tema 15. Acceder a los servicios de MsDos. Temas más avanzados.
- Tema 16. Introducción a la Programación Orientada a Objetos.
- Tema 17. Introducción al entorno Turbo Vision. (No disponible en esta versión)
Curso de Pascal. Tema 0: Introducción.
Hay distintos lenguajes que nos permiten dar instrucciones a un ordenador (un programa de ordenador no es más que eso: un conjunto de órdenes para un ordenador). El más directo es el propio del ordenador, llamado "lenguaje de máquina" o " código máquina ", formado por secuencias de ceros y unos. Este lenguaje es muy poco intuitivo para nosotros, y difícil de usar. Por ello se recurre a otros lenguajes más avanzados, más cercanos al propio lenguaje humano ( lenguajes de alto nivel ), y es entonces el mismo ordenador el que se encarga de convertirlo a algo que pueda manejar directamente. Se puede distinguir dos tipos de lenguajes, según se realice esta conversión:
- En los intérpretes , cada instrucción que contiene el programa se va conviertiendo a código máquina antes de ejecutarla, lo que hace que sean más lentos (a cambio, los intérpretes suelen ser más fáciles de crear, lo que permite que sean baratos y que puedan funcionar en ordenadores con menor potencia).
- En los compiladores , se convierte todo el programa en bloque a código máquina y después se ejecuta. Así, hay que esperar más que en un intérprete para comenzar a ver trabajar el programa, pero después éste funciona mucho más rápido (a cambio, los compiladores son más caros y suelen requerir ordenadores más potentes). Hay lenguajes para los que sólo hay disponibles intérpretes, otros para los que sólo existen compiladores, y otros en los que se puede elegir entre ambos. La mayoría de los lenguajes actuales son compilados, y el entorno de desarrollo suele incluir:
- Un editor para escribir o revisar los programas.
- El compilador propiamente dicho, que los convierte a código máquina.
- Otros módulos auxiliares, como enlazadores (linkers) para unir distintos subprogramas, y depuradores (debuggers) para ayudar a descubrir errores.
Algunos de los lenguajes más difundidos son:
- (^) BASIC , que durante mucho tiempo se ha considerado un buen lenguaje para comenzar a aprender, por su sencillez, aunque se podía tender a crear programas poco legibles. A pesar de esta "sencillez" hay versiones muy potentes, incluso para programar en entornos gráficos como Windows.
- COBOL , que fue muy utilizado para negocios (para crear software de gestión, que tuviese que manipular grandes cantidades de datos), aunque últimamente está bastante en desuso.
- FORTRAN , concebido para ingeniería, operaciones matemáticas, etc. También va quedando desplazado.
- Ensamblador , muy cercano al código máquina (es un lenguaje de "bajo nivel"), pero sustituye las secuencias de ceros y unos (bits) por palabras más fáciles de recordar, como MOV, ADD, CALL o JMP.
- C , el mejor considerado actualmente (junto con C++, desarrollado a partir de él, y junto con Java, creado a partir de este último), porque no es difícil y permite un grado de control del ordenador muy alto, combinando características de lenguajes de alto y bajo nivel. Además, es muy transportable: existe un estándar, el ANSI C, lo que asegura que se pueden convertir programas en C de un ordenador a otro o de un sistema operativo a otro con bastante menos esfuerzo que en otros lenguajes.
- PASCAL , el lenguaje estructurado (ya se irá viendo esto más adelante) por excelencia, y que en algunas versiones tiene una potencia comparable a la del lenguaje C, como es el caso de Turbo Pascal en programación para DOS y Windows. Frente al C tiene el inconveniente de que es menos portable, y la ventaja de que en el caso concreto de la programación para DOS, Turbo Pascal no tiene nada que envidiar la mayoría de versiones del lenguaje C en cuanto a potencia, y además resulta más fácil de aprender, es muy rápido, crea ficheros EXE más pequeños, etc. Dos conceptos que se mencionan mucho al hablar de programación son "programación estructurada" y "programación orientada a objetos". La programación estructura da consiste en dotar al programa de un cierto orden, dividiéndolo en bloques independientes unos de otros, que se encargan de cada una de las tareas necesarias. Esto hace un programa más facil de leer y modificar. La programación orientada a objetos se tratará más adelante, cuando ya se tenga una buena base de programación "convencional". Como simple comentario, para que vayan sonando las cosas a conocidas, diré que " Objects Pascal " es el nombre que se suele dar a un lenguaje Pascal que permita programación orientada a objetos (como es el caso de Turbo Pascal), y que " C++ " es una ampliación del lenguaje C, que también soporta P.O.O.
Curso de Pascal. Tema 1: Generalidades del Pascal.
Vamos a empezar "al revés" de lo habitual: veremos un ejemplo de programa básico en Pascal (que se limitará a escribir la palabra "Hola" en la pantalla) y comentaremos cada una de las cosas que aparecen en él: program Saludo; begin write('Hola'); end. Lo primero que llama la atención es que casi todas las palabras están escritas en inglés. Esto será lo habitual: la gran mayoría de las palabras clave de Pascal (palabras con un significado especial dentro del lenguaje) son palabras en inglés o abreviaturas de éstas. No existe distinción entre mayúsculas y minúsculas, por lo que "BEGIN" haría el mismo efecto que "begin" o "Begin". Así, lo mejor será adoptar el convenio que a cada uno le resulte más legible: algunos autores emplean las órdenes en mayúsculas y el resto en minúsculas, otros todo en minúsculas, otros todo en minúsculas salvo las iniciales de cada palabra... Yo emplearé normalmente minúsculas, o a veces mayúsculas y minúsculas combinadas cuando esto haga más legible algún comando "más enrevesado de lo habitual" (por ejemplo, si están formados por dos o más palabras inglesas como OutText o SetFillStyle.) Si sabemos un poco de inglés, podríamos traducir literalmente el programa anterior, y así podremos darnos cuenta de lo que hace (aunque en un instante lo veremos con más detalle): programa saludo comienzo escribir 'Hola' final Otra cosa que puede "chocar" es eso de que algunas líneas terminen con un punto y coma. Pues bien, cada sentencia (u orden) de Pascal debe terminar con (^) un punto y coma (;), salvo el último "end", que lo hará con un punto. También hay otras tres excepciones: no es necesario un punto y coma después de un "begin", ni antes de una palabra "end" o de un "until" (se verá la función de esta palabra clave más adelante), aunque no es mala técnica terminar siempre cada sentencia con un punto y coma, al menos hasta que se tenga bastante soltura. Cuando definamos variables, tipos, constantes, etc., veremos que tampoco va punto y coma después de las cabeceras de las declaraciones. Pero eso ya llegará... Pues ahora ya sí que vamos a ver con (^) un poco más de detalle lo que hace este programa. Comienza con la palabra program. Esta palabra no es necesaria en muchos compiladores, como Turbo Pascal o Surpas, pero sí lo era incialmente en Pascal estándar, y el formato era program NombrePrograma (input, output); (entre paréntesis se escribía "input, output" para indicar que el programa iba a manejar los dispositivos de entrada y salida). Por ejemplo, como este programa escribe en la pantalla, si alguien usa una de las primeras versiones del Pascal de GNU, o algún otro compilador que siga estrictamente el Pascal estándar, deberá poner: program Saludo(output); Aunque para nosotros no sea necesario, su empleo puede resultar cómodo si se quiere poder recordar el objetivo del programa con sólo un vistazo rápido a su cabecera. En algunos compiladores, puede que "nos regañe" si la palabra que sigue a "program" es distinta del nombre que tiene el fichero (es el caso de las primeras versiones de Tmt Pascal Lite), pero normalmente el programa funcionará a pesar de ello. En nuestro caso, a nuestro programa lo hemos llamado "Saludo". La palabra "Saludo" es un identificador. Los "identificadores" son palabras que usaremos para referirnos a una variable, una constante, el nombre de una función o de un procedimiento, etc. Ya iremos viendo todos estos conceptos, pero sí vamos a anticipar un poco uno de ellos: una variable equivale a la clásica incógnita "x" que todos hemos usado en matemáticas (eso espero), que puede tomar cualquier valor. Ahora nuestras "incógnitas" podrán tener cualquier valor (no sólo un número: también podremos guardar textos, fichas sobre personas o libros, etc) y podrán tener nombres más largos (y que expliquen mejor su contenido, no hará falta limitarnos a una única letra, como en el caso de "x"). Estos nombres de "identificadores" serán combinaciones de letras (sin acentos) y números, junto con algunos (pocos) símbolos especiales, como el de subrayado (_). No podrán empezar con un número, sino por un carácter alfabético (A a Z, sin Ñ ni acentos) o un subrayado, y no podrán contener espacios.
Así, serían identificadores correctos: Nombre_De_Programa, programa2, _SegundoPrograma pero no serían admisibles 2programa, 2ºprog, tal&tal, Prueba de programa, ProgramaParaMí (unos por empezar por números, otros por tener caracteres no aceptados, y otros por las dos cosas). Las palabras " begin " y " end " marcan el principio y el final del programa, que esta vez sólo se compone de una línea. Nótese que, como se dijo, el último "end" debe terminar con un punto. " Write " es la orden que permite escribir un texto en pantalla. El conjunto de todo lo que se desee escribir se indica entre paréntesis. Cuando se trata de un texto que queremos que aparezca "tal cual", éste se encierra entre comillas (una comilla simple para el principio y otra para el final, como aparece en el ejemplo). El punto y coma que sigue a la orden "write" no es necesario (va justo antes de un "end"), pero tampoco es un error, y puede ser cómodo, porque si después añadimos otra orden entre "write" y "end", sería dicha orden la que no necesitaría el punto y coma (estaría justo antes de "end"), pero sí que pasaría a requerirlo el "write". Se entiende, ¿verdad? ;) (Nota: si el simbolito con el que termina el último párrafo te parece raro, quizá debas leer algo sobre los "esmailis"). Para que no quede duda, probad a hacerlo: escribid ese "write" sin punto y coma al final, y vereis que no hay problema. En cambio, si ahora añadís otro "write" después, el compilador sí que protesta. La orden "write" aparece algo más a la derecha que el resto. Esto se llama (^) escritura indentada , y consiste en escribir a la misma altura todos los comandos que se encuentran a un mismo nivel, algo más a la derecha los que están en un nivel inferior, y así sucesivamente, buscando mayor legibilidad. Se irá viendo con más detalle a medida que se avanza.
Curso de Pascal. Tema 1.2: Generalidades del Pascal (y 2).
En un programa en Pascal no hay necesidad de conservar una estructura tal que aparezca cada orden en una línea distinta. Se suele hacer así por claridad, pero realmente son los puntos y coma (cuando son necesarios) lo que indica el final de una orden, por lo que el programa anterior se podría haber escrito: program Saludo; begin write('Hola') end. o bien program Saludo; begin write('Hola') end. lo que desde luego no se puede es "partir palabras": si escribimos pro gram Saludo; el ordenador creerá que "pro" y "gram" son dos órdenes distintas, y nos regañará diciendo que no sabe qué es eso. Los detalles concretos sobre cómo probar este programa dependerán del compilador que se esté utilizando. Unos tendrán un Entorno Integrado, desde el que escribir los programas y probarlos (como Turbo Pascal y Surpas), mientras que en otros hará falta un editor para teclear los programas y el compilador para probarlos (como Tmt Lite) y otros no incluyen editor en la distribución normal, pero es fácil conseguir uno adaptado para ellos (es el caso de FPK y de Gnu Pascal).
- Byte. Es un número entero, que puede valer entre 0 y 255. El espacio que ocupa en memoria es el de 1 byte, como su propio nombre indica. ( Nota : es un tipo de datos definido por Turbo Pascal, y puede no estar disponible en otros compiladores, como es el caso de GNU Pascal).
- Char. Representa a un carácter (letra, número o símbolo). Ocupa 1 byte.
- String. Es una cadena de caracteres, empleado para almacenar y representar mensajes de más de una letra (hasta 255). Ocupa 256 bytes. El formato en Pascal estándar (y en Turbo Pascal, hasta la versión 3.01) era string[n] (o string(n), según casos, como ya se han comentado), donde n es la anchura máxima que queremos almacenar en esa cadena de caracteres (de 0 a 255), y entonces ocupará n+1 bytes en memoria. En las últimas versiones de Turbo Pascal (y otros) podemos usar el formato "string[n]" o simplemente "string", que equivale a "string[255]". En otros compiladores, como GNU Pascal, el tamaño permitido es mucho mayor (normalmente por encima de las 32.000 letras).
- Real. Es un numero real con signo. Puede almacenar números con valores entre 2.9e-39 y 1.7e38 (en notación científica, e5 equivale a multiplicar por 10 elevado a 5, es decir, podremos guardar números tan grandes como un 17 seguido de 37 ceros, o tan pequeños como 0,00...029 con 38 ceros detrás de la coma). Tendremos 11 o 12 dígitos significativos y ocupan 6 bytes en memoria.
- Boolean. Es una variable lógica, que puede valer TRUE (verdadero) o FALSE (falso), y se usa para comprobar condiciones.
- Array (nota: algunos autores traducen esta palabra como " arreglo "). Se utilizan para guardar una serie de elementos, todos los cuales son del mismo tipo. Se deberá indicar el índice inferior y superior (desde dónde y hasta dónde queremos contar), separados por dos puntos (..), así como el tipo de datos. Por ejemplo, para guardar hasta 200 números enteros, usaríamos:
lista: array[1..200] of integer
Se suele emplear para definir vectores o matrices. Así, una matriz de dimensiones 3x
que debiera contener números reales sería:
matriz1: array[1..3,1..2] of real
Para mostrar en pantalla el segundo elemento de la primera lista de números (o de un
vector) se usaría
write( lista[2] );
y para ver el elemento (3,1) de la matriz,
writeln( matriz1[3,1] );
Veremos ejemplos más desarrollados de cómo se usan los Arrays cuando lleguemos al
tema 6, en el que trataremos órdenes como "for", que nos permitirán recorrer todos sus
elementos.
- Record. La principal limitación de un array es que todos los datos que contiene deben ser del mismo tipo. Pero a veces nos interesa agrupar datos de distinta naturaleza, como pueden ser el nombre y la edad de una persona, que serían del tipo string y byte, respectivamente. Entonces empleamos los records o registros , que se definen indicando el nombre y el tipo de cada campo (cada dato que guardamos en el registro), y se accede a estos campos indicando el nombre de la variable y el del campo separados por un punto:
program Ejemplo_de_registro; var dato: record nombre: string[20]; edad: byte; end;
begin dato.nombre:='José Ignacio'; dato.edad:=23; write('El nombre es ', dato.nombre ); write(' y la edad ', dato.edad, ' años.'); end. La única novedad en la definición de la variable es la aparición de una palabra end después de los nombres de los campos, lo que indica que hemos terminado de enumerar éstos. Ya dentro del cuerpo del programa, vemos la forma de acceder a estos campos, tanto para darles un valor como para imprimirlo, indicando el nombre de la variable a la que pertenecen, seguido por un punto. El conjunto := es la sentencia de asignación en Pascal, y quiere decir que la variable que aparece a su izquierda va a tomar el valor que está escrito a la derecha (por ejemplo, x := 2 daría el valor 2 a la variable x).
Curso de Pascal. Tema 2.3: Más sobre registros.
Puede parecer engorroso el hecho de escribir "dato." antes de cada campo. También hay una forma de solucionarlo: cuando vamos a realizar varias operaciones sobre los campos de un mismo registro (record), empleamos la orden with , con la que el programa anterior quedaría program Ejemplo_de_registro; var dato: record nombre: string[20]; edad: byte; end; begin with dato do begin nombre:='José Ignacio'; edad:=23; write('El nombre es ',nombre); write(' y la edad ',edad,' años.'); end; end. En este caso tenemos un nuevo bloque en el cuerpo del programa, delimitado por el "begin" y el "end" situados más a la derecha, y equivale a decir "en toda esta parte del programa me estoy refiriendo a la variable dato". Así, podemos nombrar los campos que queremos modificar o escribir, sin necesidad de repetir a qué variable pertenecen. Nota : aquí vuelve a aparecer la escritura indentada : para conseguir uan mayor legibilidad, escribimos un poco más a la derecha todo lo que depende de la orden "with". No es algo obligatorio, pero sí recomendable. Y aun hay más sobre registros. Existe una posibilidad extra, conocida como "registros variantes", que veremos más adelante. Estos tipos básicos de datos se pueden " relacionar " entre sí. Por ejemplo, podemos usar un registro (record) para guardar los datos de cada uno de nuestros amigos, y guardarlos todos juntos en un array de registros. Todo esto ya lo iremos viendo. Por cierto, si alguien ve un cierto parecido entre un (^) string y un (^) array , tiene razón: un string no es más que un "array de chars". De hecho, la definición original de "string[x]" en Pascal estándar era algo así como "packed array [1..x] of char", donde la palabra packed indicaba al compilador que tratase de compactar los datos para que ocupasen menos.
writeln(num:5); (* ¿Qué hara ahora? *) end. La salida por pantalla de este programa sería: 1.2345678900E+
1234568 1.2E+ Aquí se puede observar lo que ocurre en los distintos casos:
- Si no indicamos formato, se usa notación científica (exponencial).
- Si la anchura es mayor, añade espacios por la izquierda.
- Si es menor, no se trunca el número.
- Si el número de decimales es mayor, se añaden ceros.
- Si éste es menor, se redondea.
- Si indicamos formato pero no decimales, sigue usando notación exponencial, pero lo más compacta que pueda, tratando de llegar al tamaño que le indicamos.
Curso de Pascal. Tema 3.3: Comentarios.
En este programa ha aparecido también otra cosa nueva: los comentarios : writeln(num:20:3); (* Con tres decimales ) Un comentario es algo el compilado va a ignorar, como si no hubieramos escrito nada, y que nosotros incluimos dentro del programa para que nos resulte más legible o para aclarar lo que hace una línea o un conjunto de líneas. En Pascal, los comentarios se encierran entre ( y ). También está permitido usar { y }, tanto en Turbo Pascal como en SURPAS. Como se ve en el ejemplo, pueden ocupar más de una línea. A partir de ahora, yo emplearé los comentarios para ayudar a que se entienda un poco más el desarrollo del programa, y también para incluir una cabecera al principio, que indique el cometido del programa y los compiladores con los que ha sido comprobado. En la práctica, es muy importante que un programa esté bien documentado. Cuando se trabaja en grupo, la razón es evidente: a veces es la única forma de que los demás entiendan nuestro trabajo. En estos casos, el tener que dar explicaciones "de palabra" es contraproducente: Se pierde tiempo, las cosas se olvidan... Tampoco es cómodo distribuir las indicaciones en ficheros aparte, que se suelen extraviar en el momento más inoportuno. Lo ideal es que los comentarios aclaratorios estén siempre en el texto de nuestro programa. Pero es que cuando trabajamos solos también es importante, porque si releemos un programa un mes después de haberlo escrito, lo habitual es que ya no nos acordemos de lo que hacía la variable X, de por qué la habíamos definido como "Record" y no como "Array", por qué dejábamos en blanco la primera ficha o por qué empezábamos a ordenar desde atrás. Por cierto, que de ahora en adelante, como ya entendemos eso de los comentarios, los usaré para indicar las versiones en las que está comprobado cada uno de los programas, y para explicar un poco lo que hace. ( Nota : según el compilador que manejemos, es habitual que un comentario que empezamos con ( se deba terminar con *), y no con }. También es frecuente que no se puedan " anidar " comentarios, de modo que algo como begin
{{} end es correcto, porque la segunda llave abierta se ignora en la mayoría de los compiladores, mientras que algunos exigirán que se cierre también: begin {{}} end Puede incluso que algún compilador nos permita escoger cual de las dos opciones preferimos.
Curso de Pascal. Tema 3.4: Leer datos del usuario.
Para tomar datos del usuario , la forma más directa es empleando readln , que toma un texto o un número y asigna este valor a una variable. No avisa de lo que está haciendo, así que normalmente convendrá escribir antes en pantalla un mensaje que indique al usuario qué esperamos que teclee: writeln('Por favor, introduzca su nombre'); readln(nombre);
"Readln" tiene algunos inconvenientes :
- No termina hasta que pulsemos RETURN.
- La edición es incómoda: para corregir un error sólo podemos borrar todo lo que habíamos escrito desde entonces, no podemos usar las flechas o INICIO/FIN para desplazarnos por el texto.
- Si queremos dar un valor a una variable numérica y pulsamos " 23" (un espacio delante del número) le dará un valor 0.
- ...
A pesar de estos inconvenientes, es la forma estándar de leer datos del teclado, así vamos a ver un ejemplo de cómo usarla: {--------------------------} { Ejemplo en Pascal: } { } { Introducción de datos } { con ReadLn } { READLN.PAS } { } { Este fuente procede de } { CUPAS, curso de Pascal } { por Nacho Cabanes } { } { Comprobado con: } { - Turbo Pascal 7.0 } { - Turbo Pascal 5.0 } { - Surpas 1.00 } {--------------------------} program Readln; var nombre: string[40]; edad: byte; begin write ('Escribe tu nombre: '); readln(nombre); write ('Y ahora tu edad: '); readln(edad); write ('Hola, ',nombre,' ¿qué tal estás?'); writeln('Hola,',nombre:10,'. Tu edad es:',edad:2); end. Más adelante, veremos que existen formas mucho más versátiles y cómodas de leer datos a través del teclado, en el mismo tema en el que veamos cómo se maneja la pantalla en modo texto desde Pascal...
writeln('La división de e1 entre e2 : ', e1 / e2); writeln(' Su división entera : ', e1 div e2); writeln(' Y el resto de la división : ', e1 mod e2); writeln('El opuesto de e2 es :', -e2); end. Supongo que no habrá ninguna duda. O:-) Aun así experimentad. Y ojo con el formato de "mod", porque se parece bastante poco como se diría "el resto de dividir e1 entre e2" a la notación "e1 mod e2". Aun así, todo fácil, ¿verdad?
Curso de Pascal. Tema 4.2: Concatenar cadenas.
El operador + (suma) se puede utilizar también para concatenar cadenas de texto, así: {--------------------------} { Ejemplo en Pascal: } { } { Concatenar cadenas } { con "+" } { CONCAT.PAS } { } { Este fuente procede de } { CUPAS, curso de Pascal } { por Nacho Cabanes } { } { Comprobado con: } { - Turbo Pascal 7.0 } { - Tmt Pascal Lt 1.20 } {--------------------------} Program Concat; var texto1, texto2, texto3: string; begin texto1 := 'Hola '; texto2 := '¿Cómo estás?'; texto3 := texto1 + texto2; writeln(texto3); (* Escribirá "Hola ¿Cómo estás?" *) end. (Más adelante se dedica un apartado al manejo de cadenas de texto). Cuando tratemos tipos de datos más avanzados, veremos que +, - y * también se pueden utilizar para conjuntos , e indicarán la unión, diferencia e intersección. (Esto lo veremos más adelante, en el apartado 9.3).
Curso de Pascal. Tema 4.3: Operadores lógicos.
Vimos de pasada que en el tema que había unos tipos de datos llamados "boolean", y que podían valer TRUE (verdadero) o FALSE (falso). En la próxima lección veremos cómo hacer comparaciones del estilo de "si A es mayor que B y B es mayor que C", y empezaremos a utilizar variables de este tipo, pero vamos a mencionar ya eso del "y". Podremos encadenar proposiciones de ese tipo (si A y B entonces C) con: and (y), or (ó), not (no) y los operadores relacionales , que se usan para comparar y son los siguientes: +--------------------------------------+ ¦ Operador ¦ Operación ¦ +----------+---------------------------¦ ¦ = ¦ Igual a ¦ ¦ <> ¦ No igual a (distinto de) ¦ ¦ < ¦ Menor que ¦ ¦ > ¦ Mayor que ¦ ¦ <= ¦ Menor o igual que ¦
¦ >= ¦ Mayor o igual que ¦ +--------------------------------------+ Igual que antes, algunos de ellos (>=, <=, in) los utilizaremos también en los conjuntos, más adelante.
Curso de Pascal. Tema 4.4: Operaciones entre bits.
Los operadores "and", "or" y "not", junto con otros, se pueden utilizar también para operaciones entre bits de números enteros: +-----------------------------------------------+ ¦ Operador¦ Operación ¦ +---------+-------------------------------------¦ ¦ not ¦ Negación ¦ ¦ and ¦ Producto lógico ¦ ¦ or ¦ Suma lógica ¦ ¦ xor ¦ Suma exclusiva ¦ ¦ shl ¦ Desplazamiento hacia la izquierda ¦ ¦ shr ¦ Desplazamiento a la derecha ¦ +-----------------------------------------------+ Explicar para qué sirven estos operadores implica conocer qué es eso de los bits, cómo se pasa un número decimal a binario, etc. Supondré que se tienen las nociones básicas, y pondré un ejemplo, cuyo resultado comentaré después: {--------------------------} { Ejemplo en Pascal: } { } { Operaciones entre } { bits } { BITOPS.PAS } { } { Este fuente procede de } { CUPAS, curso de Pascal } { por Nacho Cabanes } { } { Comprobado con: } { - Turbo Pascal 7.0 } { - Tmt Pascal Lt 1.20 } {--------------------------} program BitOps; { Operaciones entre bits } const a = 67; b = 33; begin writeln('La variable a vale ', a); writeln('y b vale ', b); writeln(' El complemento de a es: ', not(a)); writeln(' El producto lógico de a y b es: ', a and b); writeln(' Su suma lógica es: ', a or b); writeln(' Su suma lógica exclusiva es: ', a xor b); writeln(' Desplacemos a a la izquierda: ', a shl 1); writeln(' Desplacemos a a la derecha: ', a shr 1); end. (Nota: he declarado dos constantes , por comodidad mía; las constantes se tratarán con más detalle en el tema 7). Veamos qué ha ocurrido. La respuesta que nos da Turbo Pascal 7.0 es la siguiente:
La variable a vale 67 y b vale 33 El complemento de a es: -
{ EJT04.PAS }
{ Este fuente procede de } { CUPAS, curso de Pascal } { por Nacho Cabanes } { } { Comprobado con: } { - Turbo Pascal 7.0 } { - Turbo Pascal 5.0 } { - Surpas 1.00 } {--------------------------} Program EjT04; begin writeln('Allá vamos... '); writeln( 5+3+452 ); writeln( (5+3)4+35-8/2+7/(3-2) ); writeln( 5 div 3 + 23 mod 4 - 4 * 5 ); end.
Curso de Pascal. Tema 5: Condiciones.
Vamos a ver cómo podemos evaluar condiciones desde Pascal. La primera construcción que trataremos es if ... then. En español sería "si ... entonces", que expresa bastante bien lo que podemos hacer con ella. El formato es " if condicion then sentencia ". Veamos un ejemplo breve antes de seguir: {--------------------------} { Ejemplo en Pascal: } { } { Primera prueba de } { "if" } { IF1.PAS } { } { Este fuente procede de } { CUPAS, curso de Pascal } { por Nacho Cabanes } { } { Comprobado con: } { - Turbo Pascal 7.0 } { - Turbo Pascal 5.0 } { - Surpas 1.00 } {--------------------------} program if1; var numero: integer; begin writeln('Escriba un número'); readln(numero); if numero>0 then writeln('El número es positivo'); end. Todo claro, ¿verdad? La "condición" debe ser una expresión que devuelva un valor del tipo " boolean " (verdadero/falso). La sentencia se ejecutará si ese valor es "cierto" (TRUE). Este valor puede ser tanto el resultado de una comparación como la anterior, como una propia variable booleana.
Curso de Pascal. Tema 5.2: Condiciones y variables boolean.
Así, una forma más "rebuscada" (pero que a veces resultará más cómoda y más legible) de hacer lo anterior sería, usando una variable " boolean ": {--------------------------} { Ejemplo en Pascal: } { } { Segunda prueba de } { "if" } { IF2.PAS } { } { Este fuente procede de } { CUPAS, curso de Pascal } { por Nacho Cabanes } { } { Comprobado con: } { - Turbo Pascal 7.0 } { - Turbo Pascal 5.0 } { - Surpas 1.00 } {--------------------------} program if2;
Curso de Pascal. Tema 5.4: Condiciones y sentencias
compuestas.
Sigamos... También podemos indicar lo que queremos que se haga si no se cumple la condición. Para ello tenemos la construcción "if condición then sentencia1 else sentencia2": {--------------------------} { Ejemplo en Pascal: } { } { Cuarta prueba de } { "if" } { IF4.PAS } { } { Este fuente procede de } { CUPAS, curso de Pascal } { por Nacho Cabanes } { } { Comprobado con: } { - Turbo Pascal 7.0 } { - Turbo Pascal 5.0 } { - Surpas 1.00 } {--------------------------} program if4; var numero: integer; begin writeln('Escriba un número'); readln(numero); if numero<0 then writeln('El número es negativo.') else writeln('El número es positivo o cero.') end. Un detalle importante que conviene tener en cuenta es que antes del "else" no debe haber un punto y coma, porque eso indicaría el final de la sentencia "if...", y el compilador nos avisaría con un error.
Curso de Pascal. Tema 5.5: Sentencias "If" encadenadas.
Las sentencias "if...then...else" se pueden encadenar : {--------------------------} { Ejemplo en Pascal: } { } { Quinta prueba de } { "if" } { IF5.PAS } { } { Este fuente procede de } { CUPAS, curso de Pascal } { por Nacho Cabanes } { } { Comprobado con: } { - Turbo Pascal 7.0 } { - Turbo Pascal 5.0 } { - Surpas 1.00 } {--------------------------} program if5;
var numero: integer; begin writeln('Escriba un número'); readln(numero); if numero<0 then writeln('El número es negativo.') else if numero>0 then writeln('El número es positivo.') else writeln('El número es cero.') end.
Curso de Pascal. Tema 5.6: Varias condiciones simultáneas.
Si se deben cumplir varias condiciones a la vez, podemos enlazarlas con "and" (y). Si se pueden cumplir varias, usaremos "or" (o). Para negar, "not" (no): if ( opcion = 1 ) and ( terminado = true ) then [...] if ( opcion = 3 ) or ( teclaPulsada = true ) then [...] if not ( preparado ) then [...] if ( opcion = 2 ) and not ( nivelDeAcceso < 40 ) then [...] Pero cuando queremos comprobar entre varios posibles valores , sería muy pesado tener que hacerlo con muchos "if" seguidos o encadenar muchos con "and" u "or".. Hay una alternativa que resulta mucho más cómoda: la orden case. Su sintaxis es case expresión of caso1: sentencia1; caso2: sentencia2; ... casoN: sentenciaN; end; o bien, si queremos indicar lo que se debe hacer si no coincide con ninguno de los valores que hemos enumerado, usamos else: case expresión of caso1: sentencia1; caso2: sentencia2; ... casoN: sentenciaN; else otraSentencia; end; En Pascal estándar , esta construcción se empleaba con otherwise en lugar de "else" para significar "en caso contrario", así que si alguien de los que me lee no usa TP/BP, sino un compilador que protesta con el "else" (es el caso de Surpas), ya sabe dónde probar... ;-) Con un ejemplito se verá más claro cómo usar "case": {--------------------------} { Ejemplo en Pascal: } { } { Condiciones múltiples } { con "case" } { CASE1.PAS } { } { Este fuente procede de } { CUPAS, curso de Pascal } { por Nacho Cabanes } { } { Comprobado con: }
