Curso de Delphi

[Khronos14]

Hola, abro este hilo para empezar un curso de introducción a Delphi. Antes de nada, aclaro que no necesitas conocimientos previos de programación para seguir el curso y que para preservar la integridad del curso no posteéis aquí.

Para este curso voy a emplear la versión de Delphi 2010. A partir de Delphi 2007, se incluyeron mejoras notables como UNICODE nativo, soporte para interfaces táctiles y los genéricos en la sintaxis de Delphi, así que para seguir este curso recomiendo usar Delphi 2009 o superior.

• Capítulo 1. Delphi.
• Capítulo 2. ¡Hola Mundo!
• Capítulo 3. Tipos de datos.
• Capítulo 4. Operadores.
• Capítulo 5. Condicionales y saltos.
• Capítulo 6. Bucles.
• Capítulo 7. Procedimientos y Funciones I.
• Capítulo 8. Vectores I.
• Capítulo 9. Estructuras.
• Capítulo 10. Punteros I.

NOTA: Si tenéis alguna duda/consejo sobre el curso o sobre cualquier cuestión de Delphi podéis consultarme por mp.

[Khronos14]

Capítulo 1. Delphi.

Delphi es un entorno de desarrollo de aplicaciones rápidas o entorno RAD (Rapid Applications Development). Delphi emplea como lenguaje de aplicación una versión moderna del Pascal, llamada Object Pascal, aunque mucha gente se refiere a Delphi como un lenguaje de programación.

¿Por qué Delphi?

Delphi es un lenguaje de programación de alto nivel con el que podrás desarrollar potentes aplicaciones como si programaras en C/C++ pero reduciendo drásticamente el tiempo de desarrollo, además nos facilita el uso de las últimas tecnologías de programación para aplicaciones Windows y Web, tanto en la plataforma Win32 como .NET.

Algunas características:

• Delphi compila a código máquina y no depende de ningún FrameWork o dependecias externas como OCX o DLLs de terceros para funcionar.
• Permite Assembler inline.
• Delphi trabaja con sus componentes VCL (Visual Component Library) y son ampliables. Puedes descargar nuevos componentes e instalarlos (algunos son de pago).
• Delphi es una estupenda elección para desarrollar aplicaciones que trabajan con motores de base de datos. De hecho, se pasó de Turbo Pascal a Delphi para ese fin, recientemente se incorporó soporte para las bases de datos FireBird.

Además Delphi cuenta con su versión para .NET llamada Delphi Prism que permite crear aplicaciones multiplataforma empleando MONO, pero este no es el objetivo de este curso.

Seguramente conozcas alguna aplicación desarrollada en Delphi, entre ellas: Skype, Ares, KMPlayer, AIMP, TuneUp, DevCpp, etc.. Aquí tienes una lista mucho más amplia:


Conocer el IDE (Integrated Development Enviroment) de Delphi, traducido como entorno de desarrollo integrado, es fundamental para desarrollar aplicaciones.



La interfaz es similar a la del Visual Studio, pero de todas formas voy a explicar lo básico en este capítulo. A primera vista tenemos una página de bienvenida en el centro del programa, que nos muestra los programas recientes y los favoritos. A la izquierda de la página de bienvenida tenemos dos paneles: Structure y Object Inspector. El primero va a mostrar todos los componentes visuales de nuestra aplicación y con el segundo podremos ver las propiedades y eventos de cada componente (ya veremos que son).

A la derecha de la página de bienvenida tenemos otros dos paneles: Project Manager y Tool Palette, el primero nos servirá para ver los archivos y la configuración de nuestro proyecto y el segundo panel es el cuadro de los componentes de Delphi.

En la parte superior de Delphi tenemos el clásico menú con las posibles configuraciones y opciones y debajo un panel con unos botones que ya iremos viendo.

[Khronos14]

Capítulo 2. ¡Hola mundo!

Para empezar a programar en Delphi, vamos a dejar de lado la interface visual y los controles y empezaremos trabajando en modo consola. Para iniciar un nuevo proyecto en Delphi vamos a File -> New -> Other -> y se nos abrirá una nueva ventana, en donde escogemos Console Application.

Tendríamos que ver algo así:



Por comodidad cerré los 4 paneles que rodeaban la pantalla principal.

Hay parte de código que de momento no nos vas a ser útil y que explicaré más adelante para que sirve. Así que quitaremos el código que se encuentra entre el begin y el end., quedando de la siguiente forma:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

begin


end.


Ahora vamos a guardar el proyecto, vamos a File -> Save all -> y le damos un nombre a nuestro proyecto, por ejemplo: "HolaMundo", una vez hayáis hecho esto, el código fuente os cambiará, quedando así:

Código (delphi) [Seleccionar] Expandir


program HolaMundo;

{$APPTYPE CONSOLE}

uses
 SysUtils;

begin


end.


Con esto podemos deducir que "HolaMundo" que está precedido de program, es el nombre de nuestro proyecto. El nombre del proyecto tiene que ser el mismo que el del archivo .dpr (Delphi Project). A continuación de esta línea encontramos {$APPTYPE CONSOLE}, esta es una de las muchas directivas de configuración que tiene Delphi, APPTYPE (Application Type) es el tipo de aplicación que vamos a crear. Si quitamos esta línea o la dejamos así {$APPTYPE GUI} Delphi generará un programa que no mostrará la pantalla de la consola. Las aplicaciones visuales, por defecto, ya ni ponen esta línea...

A continuación tenemos uses y debajo "SysUtils;". Con uses lo que haces es incluir ficheros de código fuente en nuestro programa, en este caso, el fichero SysUtils.pas. Finalmente tenemos un begin(comienzo) y un end.(final). Aquí es donde empieza nuestro programa, el programa siempre termina con un end seguido de un punto.

Delphi es un lenguaje no case sensitive (no es sensible a las mayúsculas/minúsculas), es lo mismo BEGin que begin. Esta característica está bastante desfasada, de hecho creo que solo Pascal/Object Pascal/Delphi y Basic la tienen, el resto de los lenguajes si que son sensibles a las mayúsculas, el ejemplo más claro es C o Java. Para ser sincero, esta característica me gusta bastante, evita dolores de cabeza corrigiendo mayúsculas y minúsculas...

Otra característica muy importante de Delphi es que es un lenguaje de programación fuertemente estructurado en la que hay que respetar las partes del programa. Pascal es muy estricto con este tema, no puedes declarar constantes antes que las funciones y muchas más cosas... en este aspecto Delphi es más permisivo.

Una vez aclarado esto, vamos a crear un programa que nos muestre un Hola Mundo en la consola. Para ello vamos a emplear 2 procedimientos: WriteLn y ReadLn. Una función es un conjunto de instrucciones que se ejecutan una detrás de la otra y que retornan una valor, un procedimiento es lo mismo que una función pero sin devolver ningún valor.

El procedimiento WriteLn, muestra el texto que se le pasa como parámetro en la consola. Las cadenas de caracteres en Delphi van entrecomillados por la comilla simple '. El procedimiento ReadLn() lo que hace es leer una línea que se introduce por teclado hasta que se pulse Enter, lo que va a hacer en nuestro programa es evitar que se cierre.

Código (delphi) [Seleccionar] Expandir


program HolaMundo;

{$APPTYPE CONSOLE}

uses
 SysUtils;

begin
 WriteLn('Hola mundo!');
 ReadLn;

end.


Las líneas de código que van dentro del begin y del end finalizan en punto y coma ; al igual que C o Java. Los procedimientos que no pasan parámetros pueden finalizar en () por si tienes la costumbre de C/C++/C#, de Java o de cualquier otro lenguaje, el compilador lo da por válido.

Una vez hecho esto, guardamos todo, y vamos a Project -> Compile HolaMundo. Luego pulsamos F9 o le damos al botón del Play que sale en color verde y se nos mostrará algo como esto:



El ejecutable se encuentra en la misma carpeta en la que guardamos el código fuente.

¡Felicidades, acabas de crear tu primer programa!

[Khronos14]

Capítulo 3. Tipos de datos.

A la hora de programar, ante la necesidad de trabajar con información y operar con datos empleamos las constantes y variables. Una constante es un identificador que puede hacer referencia a una cadena de caracteres, a un número entero, a un número en coma flotante, a un número hexadecimal, etc.. Su característica principal es que su valor no puede ser alterado, al contrario que las variables.

Para emplear variables, primero debemos definir que tipo de dato va a contener esa variable: texto, un número, un valor de tipo bool (cierto o false), etc...

En esta tabla puedes ver los tipos de datos más utilizados en Delphi y su equivalencia en C/C++ y Visual Basic.



En el siguiente ejemplo puedes ver el uso de constantes y como se utilizan:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

//Las constantes se deben de declarar debajo de los uses
//y siempre finalizan en ;
const
 MiCadena = 'Hola, soy una constante';
 OtraCadena = 'Adios';
 UnNumero = 4;


begin
 Writeln(MiCadena);
 Writeln(OtraCadena);
 Readln;
end.


Para definir constantes utilizamos la palabra reservada const (las palabras reservadas suelen ir en negrita) y a continuación le asignamos a nuestras constantes un identificador como nombre y les asignamos un valor mediante el =. Lo que está escrito encima de const es un comentario y sirven para comentar código y facilitar la comprensión del mismo, son ignorados por el compilador. En Delphi se pueden declarar comentarios de 3 formas:

Código (delphi) [Seleccionar] Expandir


//Mediante la doble barra como en C/C++/C#, Java y otros lenguajes...

{
 Entre llaves....
 se pueden escribir varias lineas de comentario
}

(*
 Esta es otra forma de declarar comentarios, aunque es poco conocida y usada...
 Es similar a la forma /*    */ de C
*)


Dentro del begin y del end. hacemos 2 llamadas al procedimiento Writeln y le pasamos como parámetro el contenido de las constantes MiCadena y OtraCadena

Las constantes no se pueden declarar en cualquier parte del código, generalmente se declaran debajo de los uses aunque ya veremos en otro capítulo que se pueden declarar en más sitios. A la hora de declarar constantes y variables tenemos algunas limitaciones con el nombre del identificador, estas son las normas a seguir:

• No se pueden emplear palabras reservadas como identificador, además de que no pueden existir 2 variables/constantes con el mismo identificador.
• No se pueden emplear símbolos como identificador de una constante o variable.
• Se pueden emplear mayúsculas, minúsculas, guiones bajos y números.
• Si quieres usar números para declarar constantes o variables, el identificador de la constante o variable nunca puede empezar por número.

Estos son ejemplos de identificadores de constantes y variables no válidos:

Código (delphi) [Seleccionar] Expandir


const
   1Mensaje = 'Esto es un mensaje';
   Men saje = 'Esto es otro mensaje';
   #M = 18;


Para declarar variables tenemos que poner primero la palabra reservada var y a continuación podemos definir nuestras variables. Primero se pone el identificador seguido de : y el tipo de datos que va a contener, luego se finaliza con ;. Las variables en Delphi se declaran fuera del begin y del end., mucha gente lo considera una molestia porque tiene la mala costumbre declarar variables en medio del código, de esta forma te quedan todas las variables estructuradas y un código limpio y ordenado. Para asignarle un valor a una variable se utiliza el operador de asignación := y como siempre, se termina con ;.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

const
 Pi = 3.14;
 NumeroEnHex = $FD4;
 //Para declarar un número en hexadecimal se utiliza el dolar

var
 Cadena: string;
 Numero: integer;
 EsCierto: boolean; //solo puede ser true o false
begin
 EsCierto:= true;

 Numero:= NumeroEnHex;
 Cadena:= 'Esto es una cadena';
 Writeln(Cadena);
 Cadena:= 'Esto es otra cadena';
 Writeln(Cadena);
 Readln;
 EsCierto:= false;
end.


El tipo de dato string almacena una cadena de caracteres, es muy útil y la utilizarás mucho. Integer almacena un número entero comprendido entre  -2,147,483,648 a 2,147,483,647 y Boolean solo puede tomar el valor de true (cierto) o false (falso).

Quedaría algo así:

[Khronos14]

Capítulo 4. Operadores.

Los operadores nos proporcionan la base matemática y lógica en la programación. En el capítulo anterior ya vimos un operador, el operador de asignación :=.

Operadores aritméticos.

+ Suma.
- Resta.
* Multiplicación.
/ División real.
div División entera (sólo entre números enteros).
mod Resto división.

Un ejemplo:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

var
 numero1, numero2, suma: integer;
begin
 numero1:= 3;
 numero2:= 4;

 suma:= numero1 + numero2;
end.


Si quieres declarar varias variables del mismo tipo, puedes hacerlo en la misma línea mediante una , como se muestra en el ejemplo.

Operadores relacionales.

Se emplean en las condiciones (las veremos en el próximo capítulo) y son los siguientes:

< Menor que.
> Mayor que.
= Igual que.
<> Distinto.
<= Menor o igual que.
>= Mayor o igual que.

Operadores lógicos.

And Conjunción lógica.
Or Disyunción inclusiva lógica.
Xor Disyunción exclusiva.
Not Negación lógica.
Shr Desplazamiento de bits a la derecha.
Shl Desplazamiento de bits a la izquierda.

Una vez visto esto, vamos a aprender como leer la entrada del teclado en Delphi. El procedimiento ya lo conoces: Readln();

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

var
 Cadena: string;
begin
 Write('Introduce algo: ');
 Readln(cadena);
 Writeln('Esta es la cadena que introduciste: ' + cadena);
 Readln;
end.


El procedimiento Write es idéntico al WriteLn, sólo que este último hace un salto de línea en la consola. Para leer la entrada de datos mediante el teclado, tenemos que pasarle como parámetro al procedimiento Readln la variable en la que se guardará la información de entrada. A continuación mostramos el contenido de la variable Cadena. El operador + funciona como el operador aritmético de la suma y para concatenar cadenas.

Introducimos la cadena "hola" y pulsamos Enter. Tendríamos algo como esto:



Si queremos leer del teclado un número entero,  a Readln le tenemos que pasar como parámetro una variable de tipo integer. Con unas líneas de código podemos hacer que nos pida 2 números, los sume y nos muestre su resultado.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

var
 Numero1, Numero2: integer;
begin
 Write('Introduce un numero: ');
 Readln(Numero1);
 Write('Introduce otro numero: ');
 Readln(Numero2);
 Writeln('La suma de los dos numeros es: ', Numero1 + Numero2);
 Readln;
end.




En el último Writeln, NO podemos hacer esto:

Código (delphi) [Seleccionar] Expandir


 Writeln('La suma de los dos numeros es: ' + (Numero1 + Numero2));


Esto provocaría una excepción, porque no se puede concatenar una cadena de texto con un número entero de esta forma. Poniendo la coma y a continuación el número entero, el procedimiento Writeln se encarga él solo de convertir ese número a cadena de caracteres para que se pueda mostrar por pantalla.

Para convertir un número entero a string, disponemos de la función IntToStr (Integer To String) que está declarada en la unidad SysUtils. A esta función sólo se le puede pasar como parámetro un número entero y devuelve el número en forma de cadena de caracteres.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

var
 Numero1, Numero2: integer;
begin
 Write('Introduce un numero: ');
 Readln(Numero1);
 Write('Introduce otro numero: ');
 Readln(Numero2);
 Writeln('La suma de los dos numeros es: ' +  IntToStr(Numero1 + Numero2));
 Readln;
end.


Este ejemplo realiza lo mismo que el anterior, pero emplea la función IntToStr para convertir la suma de esos dos números enteros en una cadena de caracteres, que se concatena con "La suma de los dos numeros es: ". Hay más funciones de conversión de datos que ya iremos viendo, por ejemplo: StrToInt hace lo contrario; otras funciones podrían ser: FloatToStr, StrToFloat, TryStrToInt, TryStrToFloat, etc...

Consejo: Si alguna vez desconoces donde está declarada una variable, constante, función, etc... pinchas sobre ella y le das al botón derecho y a Find Declaration. Inmediatamente te llevará a la unidad donde está declarda, y en ocasiones hay comentarios explicando lo que hace y porqué.

[Khronos14]

Capítulo 5. Condicionales y saltos.

Mediante las condiciones podemos prever errores y controlar diferentes formas de hacer una cosa. Ejemplo: Si pi es igual a 3.14... entonces hacemos esto, si es falso, hacemos esto otro.
Básicamente esa es la estructura de las condiciones, sólo que hay que emplear terminología inglesa y adaptarlo a la estructura semántica y sintáctica de Delphi. Para crear una condición hay que emplear If Then, con una condición en medio:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

var
 Verdad: boolean;
begin
 Verdad:= True;
 if Verdad = True then
   Writeln('Es verdad');
 Readln;
end.


Esta es una condición de una sola línea, si la condición se cumple, se ejecutaría el Writeln y luego seguiría con la ejecución del programa que en este caso sería hacer un Readln. Ahora vamos a ver la estructura para hacer algo en caso contrario:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

var
 Verdad: boolean;
begin
 Verdad:= False;
 if Verdad = True then
   Writeln('Es verdad') //En las condiciones de una sola linea con else no se pone ;
   else Writeln('No es verdad');
 Readln;
end.


Mediante el else podemos hacer algo en caso de que la condición no se cumpla, pero tan sólo ejecuta una línea de código. Para ejecutar varias líneas de código en un condicional tenemos que crear un begin y un end; dentro de la condición.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

var
 Numero: integer;
begin
 Numero:= 14;
 if Numero < 10 then
   begin
     Writeln('El numero es menor de 10');
     Writeln('...');
   end else
     begin
       Writeln('El numero es mayor o igual que 10');
       Writeln('...............');
     end;
 Readln;
end.


Aquí se utiliza end; para cerrar el condicional, end. solo se usa para terminar el programa.

Otro método de salto, son las estructuras case. Con ellas podemos hacer muchas comparaciones en pocas líneas.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

var
 Numero: integer;
begin
 Write('Introduce un numero: ');
 Readln(Numero);

 case Numero of
   1: Writeln('Es el numero 1');
   2: Writeln('.... el 2');
   3: Writeln('.... el 3');
   else Writeln('Otro numero...');
 end;
 Readln;
end.


El programa hace lo siguiente: Pide un que se introduzca un número, luego mediante el case of ejecuta una acción u otra. Después de cada opción se ponen 2 puntos y a continuación la línea que vas a ejecutar, si quieres escribir varias líneas por opción introduces un begin y un end; en cada una de ellas. El else es la opción por defecto, en el caso de que no coincida con ninguna de las que tenemos programadas; también puede contener varias líneas.




Otro tipo de salto es usando etiquetas y el goto. Es poco recomendable utilizarlas ya que no entran dentro de la programación estructurada y pueden provocar bucles infinitos, así que no los vamos a ver.


Calculadora versión 1.0

Vamos a hacer una pequeña calculadora en modo consola, con un menú y una serie de opciones para sumar, restar, multiplicar y dividir.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

var
 Opcion: integer;
begin
 Writeln('Calculadora version 1.0');
 Writeln('1 - Sumar dos numeros');
 Writeln('2 - Restar dos numeros');
 Writeln('3 - Multiplicar dos numeros');
 Writeln('4 - Dividir dos numeros');
 Writeln(''); //Lo dejamos en blanco para dejar una separación
 Write('Introduce una opcion: ');

 Readln;
end.


Empezamos haciendo un menú bastante sencillo, el programa según la opción que escojamos va a hacer una operación u otra.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

var
 Opcion: integer;
begin
 Writeln('Calculadora version 1.0');
 Writeln('1 - Sumar dos numeros');
 Writeln('2 - Restar dos numeros');
 Writeln('3 - Multiplicar dos numeros');
 Writeln('4 - Dividir dos numeros');
 Writeln(''); //Lo dejamos en blanco para dejar una separación

 Write('Introduce una opcion: ');
 Readln(Opcion);

 case Opcion of
   1: begin

      end;
   2: begin

      end;
   3: begin

      end;
   4: begin

      end;
   else Writeln('Introduce una opción entre 1 y 4');
 end;

 Readln;
end.


Creamos un case of para el menú y preparamos las posibles opciones para permitir varias líneas. Además ya puse la opción por defecto en caso de que no se introduzca una opción válida. Ahora tenemos que pedir 2 números, hacer las operaciones y mostrar el resultado por pantalla. Tenemos un problema con la última operación, que hay que comprobar: la división entre cero, que solucionaremos con un condicional:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

var
 Opcion: integer;
 Numero1, Numero2: integer;
begin
 //Creamos el menu de nuestro programa...
 Writeln('Calculadora version 1.0');
 Writeln('1 - Sumar dos numeros');
 Writeln('2 - Restar dos numeros');
 Writeln('3 - Multiplicar dos numeros');
 Writeln('4 - Dividir dos numeros');
 Writeln(''); //Lo dejamos en blanco para dejar una separación

 //Pedimos un numero por teclado
 Write('Introduce una opcion: ');
 Readln(Opcion);

 //Dependiendo de la opcion...
 case Opcion of
   1: begin
       //Suma
       Write('Introduce un numero: ');
       Readln(Numero1);
       Write('Introduce otro numero: ');
       Readln(Numero2);
       Writeln('El resultado de ' + IntToStr(Numero1)
         + ' + ' + IntToStr(Numero2) + ' = ' + IntToStr(Numero1 + Numero2));
      end;
   2: begin
       //Resta
       Write('Introduce un numero: ');
       Readln(Numero1);
       Write('Introduce otro numero: ');
       Readln(Numero2);
       Writeln('El resultado de ' + IntToStr(Numero1)
         + ' - ' + IntToStr(Numero2) + ' = ' + IntToStr(Numero1 - Numero2));
      end;
   3: begin
       //Multiplicacion
       Write('Introduce un numero: ');
       Readln(Numero1);
       Write('Introduce otro numero: ');
       Readln(Numero2);
       Writeln('El resultado de ' + IntToStr(Numero1)
         + ' * ' + IntToStr(Numero2) + ' = ' + IntToStr(Numero1 * Numero2));
      end;
   4: begin
       //Division
       Write('Introduce un numero: ');
       Readln(Numero1);
       Write('Introduce otro numero: ');
       Readln(Numero2);
       if Numero2 <> 0 then
         Writeln('El resultado de ' + IntToStr(Numero1)
           + ' / ' + IntToStr(Numero2) + ' = ' + IntToStr(Numero1 div Numero2)) //División entera
       else Writeln('El divisor no puede ser 0 :(');
      end;
   else Writeln('Introduce una opción entre 1 y 4'); //Error
 end;

 Readln;
end.


Tendríamos algo como esto:




Para mostrar el resultado de una operación utilizamos Writeln y concatenamos la cadena de salida con el operador +. Como puedes observar, en la opción de suma aparece también el operador + para sumar dos números enteros. En la opción 4 comprobamos que el segundo número no es 0, si no es así mostramos un mensaje de error (cuidado con el punto y coma al final de la línea del condicional, este es el único caso en el que no se necesita).

Esta "calculadora" se puede mejorar mucho, planteé el programa de esta forma para repasar los condicionales y saltos.

[Khronos14]

Capítulo 6. Bucles.

Los bucles son un conjunto de instrucciones que se repiten una serie determinada de veces hasta que la condición deje de cumplirse. Son extremadamente útiles e imprescindibles en la programación.

En delphi tenemos 3 tipos de bucles:

• Bucles For. Repiten una acción un número determinado de veces, pueden ser bucles ascendentes o descendentes.
• Bucles While (mientras). Repiten una serie de instrucciones hasta que la condición se cumpla.
• Bucles Repeat..Until. Es parecido al bucle while pero la condición se realiza al final de cada instancia del bucle.

Bucles For.
En este tipo de bucles necesitaremos una variable que actuará como contador, generalmente será de tipo integer aunque también podría ser de tipo char.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var
Contador: integer;
begin
  for Contador := 0 to 10 do
    Writeln('El contador vale: ', Contador);

  Readln;
end.


El bucle for vendría a significar algo como "desde 0 hasta 10 hacemos esto...". En cada instancia del bucle, el valor de Contador se incrementa en 1. Como ocurre con los condicionales, si dentro del bucle no ponemos begin y end;, el bucle sólo ejecuta una línea de código.

Para hacer un bucle for descendente, hay que utilizar downto y cambiar el valor de inicio y el valor final del bucle.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var
Contador: integer;
begin
  for Contador := 10 downto 1 do
    begin
      Writeln('El contador vale: ', Contador);
      Writeln('Restamos 1..');
    end;

  Readln;
end.


Conseguiríamos algo como esto:



Bucles While

Los bucles while se basan en una condición al principio del bucle que se llama a cada nueva instancia del bucle. Veamos un ejemplo:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
SysUtils;

var
i: integer = 1; //Las variables se pueden inicializar de esta forma...
begin

while i <= 10 do
  begin
    Writeln('Esta es la instancia numero: ', i);
    Inc(i);
  end;

Readln;
end.


El significado del bucle while sería "mientras i sea menor o igual que 10 hacemos esto...". En este bucle, si utilizamos un contador de tipo entero, tenemos que incrementar su valor en cada instancia del bucle, si no tendríamos un bucle infinito. El procedimiento Inc incrementa en 1 el valor de la variable que se le pase como parámetro, el procedimiento contrario es Dec.

Bucles Repeat...Until.

Se traduce como repetir..hasta. Funciona de la misma manera que el bucle while, pero la condición se realiza al final del bucle.
Veamos como funciona con un ejemplo:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
SysUtils;

var
i: integer = 1; //Las variables se pueden inicializar de esta forma...
begin

repeat
    Writeln('Esta es la instancia numero: ', i);
    Inc(i);
until I > 10;

Readln;
end.


La traducción sería: "repetir hasta que i sea mayor que 10". En el bucle repeat..until no se emplea begin y end; para escribir varias líneas, de hecho, no hace falta.

La utilidad de los bucles while y repeat..until es que se puede utilizar como condición cualquier variable o condición. Por ejemplo:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
SysUtils;

var
Salida: string;
begin

repeat
    Write('Introduce "salir": ');
    Readln(Salida);
until Salida = 'salir';

Readln;
end.


En este ejemplo, utilizamos como condición de salida una variable de tipo string. La ejecución del bucle no termina hasta que ingresemos por el teclado la palabra "salir".

Interrumpir un bucle

Para trabajar con bucles tenemos 2 métodos bastante útiles: el método Break y el método Continue. El método break interrumpe un bucle y sale de él.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
SysUtils;

var
i: integer;
begin

for i := 0 to 10 do
    begin
      Writeln('I vale: ', i);
      if I = 7 then
        break;
    end;

Readln;
end.


En este ejemplo, se tendría que escribir en la consola 11 veces el mensaje "I vale: x". Pero dentro del bucle puse una condición de que si I vale 7, salga del bucle.

Continue sirve para saltarnos una instancia del bucle, pero no sale de él. Ejemplo:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
SysUtils;

var
i: integer;
begin

for i := 0 to 10 do
    begin
      if I = 5 then
        Continue; //No ejecuta el Writeln
      Writeln('I vale: ', i);
    end;

Readln;
end.


Si ejecutamos el programa, podemos observar que no escribe en la consola "I vale: 5" porque esa instancia se la salta.

[Khronos14]

Capítulo 7. Procedimientos y Funciones I.

Como vimos anteriormente los Procedimientos, al contrario que las funciones, no devuelven ningún valor. Para declarar un procedimiento empleamos la siguiente sintaxis:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

procedure MiProcedimiento;
begin

end;

begin

end.


En el archivo .dpr del programa los procedimientos y funciones se declaran siempre encima del begin y del end. (es el punto de entrada del programa o EntryPoint). Utilizamos la palabra reservada procedure y a continuación ponemos el identificador de nuestro procedimiento seguido de un punto y coma. El identificador de los procedimientos y funciones siguen las mismas reglas que las variables y constantes. A continuación ponemos un begin y un end; terminado en punto y coma. Una vez hecho esto, podemos poner código dentro de nuestro procedimiento entre el begin y el end;.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

procedure MiProcedimiento;
begin
  Writeln('Este es mi procedimiento');
  Writeln('....');
end;

begin
  MiProcedimiento; //También sirve MiProcedimiento();
  Readln;
end.


El procedimiento escribe un par de líneas en la consola y lo llamamos desde el punto de entrada de nuestro programa.

Para declarar una función utilizamos la palabra reservada function y sigue las mismas reglas que los procedimientos, excepto que después del identificador de la función va seguida de : y el tipo de dato a devolver.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

function Funcion: integer;
var
Operacion: integer;
begin
  Operacion:= ((14 * 27) div 2) - 4;
  Result:= Operacion; //También vale Funcion:= Operacion;
end;

begin
  Writeln('Funcion: ', Funcion);
  Readln;
end.


Nuestra función devuelve un valor entero. Dentro de un procedimiento y función se pueden declarar nuevas variables que solamente son accesibles desde el interior de ellas. Para ello se declaran antes del begin.
Para devolver el valor de la función se emplea Result seguido del operador de asignación aunque también sirve empleando el nombre de la función. Al contrario que C/C++ y otros lenguajes de programación, el hecho de llamar a result no interrumpe la ejecución de la función. Si quieres interrumpir la ejecución de un procedimiento o función puedes emplear Exit;.

Paso de parámetros

Para que una función o procedimiento reciba unos parámetros se realiza de la siguiente forma:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

function Suma(a: integer; b: integer): integer;
begin
  Result:= a + b;
end;

begin
  Writeln('Suma: ', Suma(2, 3));
  Readln;
end.


Los parámetros se declaran a continuación del identificador de la función o procedimiento, entre paréntesis. Los parámetros se separan con punto y coma, aunque si son del mismo tipo se pueden declarar así:

Código (delphi) [Seleccionar] Expandir


function Suma(a,b: integer; mensaje: string): integer;
begin
  Writeln(Mensaje);
  Result:= a + b;
end;


Los parámetros que se pasan a una función/procedimiento se pueden modificar dentro de ella. Para evitar esto, los parámetros se pueden declarar como constantes. Según el libro Delphi 5, declarar los parámetros como constantes optimizan el ejecutable generado, así que si sus valores no van a variar, es un buen hábito.

Código (delphi) [Seleccionar] Expandir


function Resta(const a, b: integer): integer;
begin
  Result:= a - b;
end;


Si en tu programa tienes varias funciones/procedimientos tienes que plantear el orden de declaración para que no se produzcan errores. Por ejemplo:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

procedure Proc1;
begin
  Proc2;
end;

procedure Proc2;
begin
  Writeln('Hacer algo');
end;

begin
  Readln;
end.


Este código NO se podría compilar, el compilador daría una excepción. En el procedimiento Proc1 se está llamando a Proc2 que está declarado a continuación, así que Proc1 no tiene ninguna referencia para llamar a Proc2 por lo que se produce un error. Para corregir este error, bastaría con poner Proc2 encima de Proc1.

Dentro de unos cuantos capítulos veremos como declarar funciones y procedimientos en archivos .pas y tendríamos otra forma de solucionar este error.

[Khronos14]

Capítulo 8. Vectores I.

Los vectores o matrices, en inglés Arrays, es una zona de almacenamiento contiguo, que contiene una serie de elementos del mismo tipo, los elementos de una matriz. Son muy utilizados en programación y se declaran empleando la palabra reservada array.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var
  Lista: array [0..3] of integer;
begin
  Lista[0]:= 3;
  Lista[1]:= 7;
  Lista[2]:= 16;
  Lista[3]:= 15;
end.


La sintaxis es simple: se emplea array a continuación el rango del vector entre corchetes y con 2 puntos, y para terminar la palabra reservada of y el tipo de dato. Para acceder a los elementos se emplea el identificador de la variable y el número de elemento va entre corchetes.

En C/C++ y otros lenguajes, la primera posición de un array siempre es 0, en Delphi esta restricción no existe, pudiendo declarar el rango que quieras dentro del array (siempre que sea positiva y no sea descendente). Ejemplo:

Código (delphi) [Seleccionar] Expandir


var
  Lista: array [14..18] of integer;


De esta forma un array puede no tener su primera posición en 0, por lo que surgen 2 funciones para determinar la primera posición del array  y la última: Low y High. Son más utilizadas en arrays dinámicos (que ya los veremos) pero también se pueden emplear.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var
  i: integer;
  Lista: array [12..15] of integer;
begin

for i := 12 to 15 do
  Lista[i]:= i;
end.


Con Low y High sería así:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var
  i: integer;
  Lista: array [12..15] of integer;
begin

for i := Low(Lista) to High(Lista) do
  Lista[i]:= i;
end.


Arrays Inicializados.

Existe la posibilidad de declarar un array con sus valores inicializados. Ejemplo:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var
  Meses: array [1..12] of string = ('Enero', 'Febrero',
  'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto',
  'Septiembre', 'Octubre', 'Noviembre', 'Diciembre');
  Mes: integer;
begin

  Write('Introduce el numero del mes: ');
  Readln(Mes);
  if (Mes >= 1) and (Mes <= 12) then
    Writeln('Estamos en : ' + Meses[Mes]);

  Readln;
end.


La variable Meses se declara un array de tipo string, con los valores de los Meses. Para inicializar un array con valores, se tienen que introducir exactamente el número de elementos. No puedes declarar un array con 12 meses y inicializar 11 meses.

Tendríamos algo como esto:



Arrays Multidimensionales.

Existe la posibilidad de crear arrays con varias dimensiones.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
  SysUtils;

var
  Matriz: array [1..4, 1..5] of integer;
  //Matriz bidimensional
begin
  Matriz[1,2]:= 5;
  Readln;
end.


[Khronos14]

Capítulo 9. Estructuras.

Las estructuras son tipos de datos que contienen otros datos, es una agrupación de variables bajo un identificador común. Para crear una estructura debemos definirla con el método type que con el se pueden definir nuevos tipos de datos.

Por ejemplo:

Código (delphi) [Seleccionar] Expandir


type
  Cadena = string;


De esta forma definimos un nuevo tipo de datos, llamado Cadena, que es tipo string. Después se podría crear una variable con el nuevo tipo de dato.

Código (delphi) [Seleccionar] Expandir


var
Prueba: Cadena;


Puedes definir tipos de datos, que se conocen como datos tipo enum. Son como constantes que tienen un valor numérico, pero los identificas con una cadena.

Código (delphi) [Seleccionar] Expandir


type
 Coche = (seat, bmw, golf, mercedes, ferrari, porsche);


De esta forma, definimos el tipo de dato Coche que solo puede tomar los valores entre paréntesis. En realidad, el tipo de datos Coche es numérico positivo, seat corresponde al 0, bmw al 1, etc...

Un ejemplo de como usarlo:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

type
 Coche = (seat, bmw, golf, mercedes, ferrari, porsche);

var
 MiCoche: Coche;
begin
 MiCoche:= bmw;
end.


Para crear una estructura se emplea la directiva record, en C se llama struct.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

type
 Agenda = record
   Nombre: string;
   Apellidos: string;
   Telefono: integer;
 end;

begin

end.


Definimos el tipo de datos Agenda, que es una estructura, y en su interior contiene 3 subvariables: Nombre, Apellidos y Telefono. Para acceder a las variables de la estructura haríamos algo como esto:

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

type
 Agenda = record
   Nombre: string;
   Apellidos: string;
   Telefono: integer;
 end;

var
 MiAgenda: Agenda;
begin
 MiAgenda.Nombre:= 'Pepe';
 MiAgenda.Apellidos:= 'No tengo apellidos';
 MiAgenda.Telefono:= 62352352;
end.


Creamos la variable MiAgenda que es del tipo Agenda, que acabamos de crear. Para acceder a las subvariables se pone un . y el nombre de la variable.

Las estructuras son muy útiles en programación y se emplean mucho. Cuando quieres volcar estructuras en ficheros y trabajar con la memoria de forma más compacta, tienes que declarar la estructura como packed record y la estructura tiene que tener tamaño fijo. Es decir, una estructura que vas a volcar en un fichero no puede tener una variable de tipo string, porque no tiene tamaño fijo... esto ya lo veremos más adelante cuando veamos ficheros.

Código (delphi) [Seleccionar] Expandir


program Project1;

{$APPTYPE CONSOLE}

uses
 SysUtils;

type
 Agenda = packed record
   Nombre: array[0..49] of char;
   Apellidos: array[0..99] of char;
   Telefono: integer;
 end;

var
 MiAgenda: Agenda;
begin
 MiAgenda.Nombre:= 'Pepe';
 MiAgenda.Apellidos:= 'No tengo apellidos';
 MiAgenda.Telefono:= 62352352;
end.


En este ejemplo, la variable Nombre sólo puede contener 50 caracteres y Apellidos 100. Trabajar con variables que almacenan caracteres de tamaño fijo, como es el caso, puede suponer errores de desbordamiento (Buffer Overflow) si no sabes lo que haces.