elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Top 20 herramientas Hacking más populares de 2020


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  Curso de Delphi
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] 2 Ir Abajo Respuesta Imprimir
Autor Tema: Curso de Delphi  (Leído 33,000 veces)
Khronos14


Desconectado Desconectado

Mensajes: 443


A lie is a lie


Ver Perfil WWW
Curso de Delphi
« en: 6 Octubre 2010, 16:00 pm »

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.


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


« Última modificación: 30 Octubre 2010, 15:31 pm por Khronos14 » En línea

Khronos14


Desconectado Desconectado

Mensajes: 443


A lie is a lie


Ver Perfil WWW
Re: Curso de Delphi
« Respuesta #1 en: 6 Octubre 2010, 16:19 pm »

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.



« Última modificación: 6 Octubre 2010, 22:43 pm por Khronos14 » En línea

Khronos14


Desconectado Desconectado

Mensajes: 443


A lie is a lie


Ver Perfil WWW
Re: Curso de Delphi
« Respuesta #2 en: 6 Octubre 2010, 22:41 pm »

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. begin
  9.  
  10.  
  11. end.
  12.  

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
  1. program HolaMundo;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. begin
  9.  
  10.  
  11. end.
  12.  

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
  1. program HolaMundo;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. begin
  9.  WriteLn('Hola mundo!');
  10.  ReadLn;
  11.  
  12. end.
  13.  

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!





« Última modificación: 7 Octubre 2010, 21:54 pm por Khronos14 » En línea

Khronos14


Desconectado Desconectado

Mensajes: 443


A lie is a lie


Ver Perfil WWW
Re: Curso de Delphi
« Respuesta #3 en: 7 Octubre 2010, 22:35 pm »

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. //Las constantes se deben de declarar debajo de los uses
  9. //y siempre finalizan en ;
  10. const
  11.  MiCadena = 'Hola, soy una constante';
  12.  OtraCadena = 'Adios';
  13.  UnNumero = 4;
  14.  
  15.  
  16. begin
  17.  Writeln(MiCadena);
  18.  Writeln(OtraCadena);
  19.  Readln;
  20. end.
  21.  

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
  1. //Mediante la doble barra como en C/C++/C#, Java y otros lenguajes...
  2.  
  3. {
  4.   Entre llaves....
  5.   se pueden escribir varias lineas de comentario
  6. }
  7.  
  8. (*
  9.   Esta es otra forma de declarar comentarios, aunque es poco conocida y usada...
  10.   Es similar a la forma /*    */ de C
  11. *)
  12.  

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
  1. const
  2.    1Mensaje = 'Esto es un mensaje';
  3.    Men saje = 'Esto es otro mensaje';
  4.    #M = 18;
  5.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. const
  9.  Pi = 3.14;
  10.  NumeroEnHex = $FD4;
  11.  //Para declarar un número en hexadecimal se utiliza el dolar
  12.  
  13. var
  14.  Cadena: string;
  15.  Numero: integer;
  16.  EsCierto: boolean; //solo puede ser true o false
  17. begin
  18.  EsCierto:= true;
  19.  
  20.  Numero:= NumeroEnHex;
  21.  Cadena:= 'Esto es una cadena';
  22.  Writeln(Cadena);
  23.  Cadena:= 'Esto es otra cadena';
  24.  Writeln(Cadena);
  25.  Readln;
  26.  EsCierto:= false;
  27. end.
  28.  

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í:





« Última modificación: 12 Octubre 2010, 00:18 am por Khronos14 » En línea

Khronos14


Desconectado Desconectado

Mensajes: 443


A lie is a lie


Ver Perfil WWW
Re: Curso de Delphi
« Respuesta #4 en: 8 Octubre 2010, 23:36 pm »

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  numero1, numero2, suma: integer;
  10. begin
  11.  numero1:= 3;
  12.  numero2:= 4;
  13.  
  14.  suma:= numero1 + numero2;
  15. end.
  16.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  Cadena: string;
  10. begin
  11.  Write('Introduce algo: ');
  12.  Readln(cadena);
  13.  Writeln('Esta es la cadena que introduciste: ' + cadena);
  14.  Readln;
  15. end.
  16.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  Numero1, Numero2: integer;
  10. begin
  11.  Write('Introduce un numero: ');
  12.  Readln(Numero1);
  13.  Write('Introduce otro numero: ');
  14.  Readln(Numero2);
  15.  Writeln('La suma de los dos numeros es: ', Numero1 + Numero2);
  16.  Readln;
  17. end.
  18.  



En el último Writeln, NO podemos hacer esto:

Código
  1.  Writeln('La suma de los dos numeros es: ' + (Numero1 + Numero2));
  2.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  Numero1, Numero2: integer;
  10. begin
  11.  Write('Introduce un numero: ');
  12.  Readln(Numero1);
  13.  Write('Introduce otro numero: ');
  14.  Readln(Numero2);
  15.  Writeln('La suma de los dos numeros es: ' +  IntToStr(Numero1 + Numero2));
  16.  Readln;
  17. end.
  18.  

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é.

« Última modificación: 12 Octubre 2010, 00:20 am por Khronos14 » En línea

Khronos14


Desconectado Desconectado

Mensajes: 443


A lie is a lie


Ver Perfil WWW
Re: Curso de Delphi
« Respuesta #5 en: 12 Octubre 2010, 00:08 am »

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  Verdad: boolean;
  10. begin
  11.  Verdad:= True;
  12.  if Verdad = True then
  13.    Writeln('Es verdad');
  14.  Readln;
  15. end.
  16.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  Verdad: boolean;
  10. begin
  11.  Verdad:= False;
  12.  if Verdad = True then
  13.    Writeln('Es verdad') //En las condiciones de una sola linea con else no se pone ;
  14.    else Writeln('No es verdad');
  15.  Readln;
  16. end.
  17.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  Numero: integer;
  10. begin
  11.  Numero:= 14;
  12.  if Numero < 10 then
  13.    begin
  14.      Writeln('El numero es menor de 10');
  15.      Writeln('...');
  16.    end else
  17.      begin
  18.        Writeln('El numero es mayor o igual que 10');
  19.        Writeln('...............');
  20.      end;
  21.  Readln;
  22. end.
  23.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  Numero: integer;
  10. begin
  11.  Write('Introduce un numero: ');
  12.  Readln(Numero);
  13.  
  14.  case Numero of
  15.    1: Writeln('Es el numero 1');
  16.    2: Writeln('.... el 2');
  17.    3: Writeln('.... el 3');
  18.    else Writeln('Otro numero...');
  19.  end;
  20.  Readln;
  21. end.
  22.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  Opcion: integer;
  10. begin
  11.  Writeln('Calculadora version 1.0');
  12.  Writeln('1 - Sumar dos numeros');
  13.  Writeln('2 - Restar dos numeros');
  14.  Writeln('3 - Multiplicar dos numeros');
  15.  Writeln('4 - Dividir dos numeros');
  16.  Writeln(''); //Lo dejamos en blanco para dejar una separación
  17.  Write('Introduce una opcion: ');
  18.  
  19.  Readln;
  20. end.
  21.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  Opcion: integer;
  10. begin
  11.  Writeln('Calculadora version 1.0');
  12.  Writeln('1 - Sumar dos numeros');
  13.  Writeln('2 - Restar dos numeros');
  14.  Writeln('3 - Multiplicar dos numeros');
  15.  Writeln('4 - Dividir dos numeros');
  16.  Writeln(''); //Lo dejamos en blanco para dejar una separación
  17.  
  18.  Write('Introduce una opcion: ');
  19.  Readln(Opcion);
  20.  
  21.  case Opcion of
  22.    1: begin
  23.  
  24.       end;
  25.    2: begin
  26.  
  27.       end;
  28.    3: begin
  29.  
  30.       end;
  31.    4: begin
  32.  
  33.       end;
  34.    else Writeln('Introduce una opción entre 1 y 4');
  35.  end;
  36.  
  37.  Readln;
  38. end.
  39.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  Opcion: integer;
  10.  Numero1, Numero2: integer;
  11. begin
  12.  //Creamos el menu de nuestro programa...
  13.  Writeln('Calculadora version 1.0');
  14.  Writeln('1 - Sumar dos numeros');
  15.  Writeln('2 - Restar dos numeros');
  16.  Writeln('3 - Multiplicar dos numeros');
  17.  Writeln('4 - Dividir dos numeros');
  18.  Writeln(''); //Lo dejamos en blanco para dejar una separación
  19.  
  20.  //Pedimos un numero por teclado
  21.  Write('Introduce una opcion: ');
  22.  Readln(Opcion);
  23.  
  24.  //Dependiendo de la opcion...
  25.  case Opcion of
  26.    1: begin
  27.        //Suma
  28.        Write('Introduce un numero: ');
  29.        Readln(Numero1);
  30.        Write('Introduce otro numero: ');
  31.        Readln(Numero2);
  32.        Writeln('El resultado de ' + IntToStr(Numero1)
  33.          + ' + ' + IntToStr(Numero2) + ' = ' + IntToStr(Numero1 + Numero2));
  34.       end;
  35.    2: begin
  36.        //Resta
  37.        Write('Introduce un numero: ');
  38.        Readln(Numero1);
  39.        Write('Introduce otro numero: ');
  40.        Readln(Numero2);
  41.        Writeln('El resultado de ' + IntToStr(Numero1)
  42.          + ' - ' + IntToStr(Numero2) + ' = ' + IntToStr(Numero1 - Numero2));
  43.       end;
  44.    3: begin
  45.        //Multiplicacion
  46.        Write('Introduce un numero: ');
  47.        Readln(Numero1);
  48.        Write('Introduce otro numero: ');
  49.        Readln(Numero2);
  50.        Writeln('El resultado de ' + IntToStr(Numero1)
  51.          + ' * ' + IntToStr(Numero2) + ' = ' + IntToStr(Numero1 * Numero2));
  52.       end;
  53.    4: begin
  54.        //Division
  55.        Write('Introduce un numero: ');
  56.        Readln(Numero1);
  57.        Write('Introduce otro numero: ');
  58.        Readln(Numero2);
  59.        if Numero2 <> 0 then
  60.          Writeln('El resultado de ' + IntToStr(Numero1)
  61.            + ' / ' + IntToStr(Numero2) + ' = ' + IntToStr(Numero1 div Numero2)) //División entera
  62.        else Writeln('El divisor no puede ser 0 :(');
  63.       end;
  64.    else Writeln('Introduce una opción entre 1 y 4'); //Error
  65.  end;
  66.  
  67.  Readln;
  68. end.
  69.  

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.
« Última modificación: 12 Octubre 2010, 12:57 pm por Khronos14 » En línea

Khronos14


Desconectado Desconectado

Mensajes: 443


A lie is a lie


Ver Perfil WWW
Re: Curso de Delphi
« Respuesta #6 en: 12 Octubre 2010, 12:56 pm »

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9. Contador: integer;
  10. begin
  11.  for Contador := 0 to 10 do
  12.    Writeln('El contador vale: ', Contador);
  13.  
  14.  Readln;
  15. end.
  16.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9. Contador: integer;
  10. begin
  11.  for Contador := 10 downto 1 do
  12.    begin
  13.      Writeln('El contador vale: ', Contador);
  14.      Writeln('Restamos 1..');
  15.    end;
  16.  
  17.  Readln;
  18. end.
  19.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6. SysUtils;
  7.  
  8. var
  9. i: integer = 1; //Las variables se pueden inicializar de esta forma...
  10. begin
  11.  
  12. while i <= 10 do
  13.  begin
  14.    Writeln('Esta es la instancia numero: ', i);
  15.    Inc(i);
  16.  end;
  17.  
  18. Readln;
  19. end.
  20.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6. SysUtils;
  7.  
  8. var
  9. i: integer = 1; //Las variables se pueden inicializar de esta forma...
  10. begin
  11.  
  12. repeat
  13.    Writeln('Esta es la instancia numero: ', i);
  14.    Inc(i);
  15. until I > 10;
  16.  
  17. Readln;
  18. end.
  19.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6. SysUtils;
  7.  
  8. var
  9. Salida: string;
  10. begin
  11.  
  12. repeat
  13.    Write('Introduce "salir": ');
  14.    Readln(Salida);
  15. until Salida = 'salir';
  16.  
  17. Readln;
  18. end.
  19.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6. SysUtils;
  7.  
  8. var
  9. i: integer;
  10. begin
  11.  
  12. for i := 0 to 10 do
  13.    begin
  14.      Writeln('I vale: ', i);
  15.      if I = 7 then
  16.        break;
  17.    end;
  18.  
  19. Readln;
  20. end.
  21.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6. SysUtils;
  7.  
  8. var
  9. i: integer;
  10. begin
  11.  
  12. for i := 0 to 10 do
  13.    begin
  14.      if I = 5 then
  15.        Continue; //No ejecuta el Writeln
  16.      Writeln('I vale: ', i);
  17.    end;
  18.  
  19. Readln;
  20. end.
  21.  

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

En línea

Khronos14


Desconectado Desconectado

Mensajes: 443


A lie is a lie


Ver Perfil WWW
Re: Curso de Delphi
« Respuesta #7 en: 26 Octubre 2010, 16:30 pm »

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. procedure MiProcedimiento;
  9. begin
  10.  
  11. end;
  12.  
  13. begin
  14.  
  15. end.
  16.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. procedure MiProcedimiento;
  9. begin
  10.  Writeln('Este es mi procedimiento');
  11.  Writeln('....');
  12. end;
  13.  
  14. begin
  15.  MiProcedimiento; //También sirve MiProcedimiento();
  16.  Readln;
  17. end.
  18.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. function Funcion: integer;
  9. var
  10. Operacion: integer;
  11. begin
  12.  Operacion:= ((14 * 27) div 2) - 4;
  13.  Result:= Operacion; //También vale Funcion:= Operacion;
  14. end;
  15.  
  16. begin
  17.  Writeln('Funcion: ', Funcion);
  18.  Readln;
  19. end.
  20.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. function Suma(a: integer; b: integer): integer;
  9. begin
  10.  Result:= a + b;
  11. end;
  12.  
  13. begin
  14.  Writeln('Suma: ', Suma(2, 3));
  15.  Readln;
  16. end.
  17.  

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
  1. function Suma(a,b: integer; mensaje: string): integer;
  2. begin
  3.  Writeln(Mensaje);
  4.  Result:= a + b;
  5. end;
  6.  

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
  1. function Resta(const a, b: integer): integer;
  2. begin
  3.  Result:= a - b;
  4. end;
  5.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. procedure Proc1;
  9. begin
  10.  Proc2;
  11. end;
  12.  
  13. procedure Proc2;
  14. begin
  15.  Writeln('Hacer algo');
  16. end;
  17.  
  18. begin
  19.  Readln;
  20. end.
  21.  

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.
En línea

Khronos14


Desconectado Desconectado

Mensajes: 443


A lie is a lie


Ver Perfil WWW
Re: Curso de Delphi
« Respuesta #8 en: 26 Octubre 2010, 17:06 pm »

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  Lista: array [0..3] of integer;
  10. begin
  11.  Lista[0]:= 3;
  12.  Lista[1]:= 7;
  13.  Lista[2]:= 16;
  14.  Lista[3]:= 15;
  15. end.
  16.  

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
  1. var
  2.  Lista: array [14..18] of integer;
  3.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  i: integer;
  10.  Lista: array [12..15] of integer;
  11. begin
  12.  
  13. for i := 12 to 15 do
  14.  Lista[i]:= i;
  15. end.
  16.  

Con Low y High sería así:

Código
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  i: integer;
  10.  Lista: array [12..15] of integer;
  11. begin
  12.  
  13. for i := Low(Lista) to High(Lista) do
  14.  Lista[i]:= i;
  15. end.
  16.  

Arrays Inicializados.

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

Código
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  Meses: array [1..12] of string = ('Enero', 'Febrero',
  10.  'Marzo', 'Abril', 'Mayo', 'Junio', 'Julio', 'Agosto',
  11.  'Septiembre', 'Octubre', 'Noviembre', 'Diciembre');
  12.  Mes: integer;
  13. begin
  14.  
  15.  Write('Introduce el numero del mes: ');
  16.  Readln(Mes);
  17.  if (Mes >= 1) and (Mes <= 12) then
  18.    Writeln('Estamos en : ' + Meses[Mes]);
  19.  
  20.  Readln;
  21. end.
  22.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. var
  9.  Matriz: array [1..4, 1..5] of integer;
  10.  //Matriz bidimensional
  11. begin
  12.  Matriz[1,2]:= 5;
  13.  Readln;
  14. end.
  15.  
En línea

Khronos14


Desconectado Desconectado

Mensajes: 443


A lie is a lie


Ver Perfil WWW
Re: Curso de Delphi
« Respuesta #9 en: 30 Octubre 2010, 00:44 am »

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
  1. type
  2.   Cadena = string;
  3.  

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
  1. var
  2. Prueba: Cadena;
  3.  

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
  1. type
  2.  Coche = (seat, bmw, golf, mercedes, ferrari, porsche);
  3.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. type
  9.  Coche = (seat, bmw, golf, mercedes, ferrari, porsche);
  10.  
  11. var
  12.  MiCoche: Coche;
  13. begin
  14.  MiCoche:= bmw;
  15. end.
  16.  

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

Código
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. type
  9.  Agenda = record
  10.    Nombre: string;
  11.    Apellidos: string;
  12.    Telefono: integer;
  13.  end;
  14.  
  15. begin
  16.  
  17. end.
  18.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. type
  9.  Agenda = record
  10.    Nombre: string;
  11.    Apellidos: string;
  12.    Telefono: integer;
  13.  end;
  14.  
  15. var
  16.  MiAgenda: Agenda;
  17. begin
  18.  MiAgenda.Nombre:= 'Pepe';
  19.  MiAgenda.Apellidos:= 'No tengo apellidos';
  20.  MiAgenda.Telefono:= 62352352;
  21. end.
  22.  

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
  1. program Project1;
  2.  
  3. {$APPTYPE CONSOLE}
  4.  
  5. uses
  6.  SysUtils;
  7.  
  8. type
  9.  Agenda = packed record
  10.    Nombre: array[0..49] of char;
  11.    Apellidos: array[0..99] of char;
  12.    Telefono: integer;
  13.  end;
  14.  
  15. var
  16.  MiAgenda: Agenda;
  17. begin
  18.  MiAgenda.Nombre:= 'Pepe';
  19.  MiAgenda.Apellidos:= 'No tengo apellidos';
  20.  MiAgenda.Telefono:= 62352352;
  21. end.
  22.  

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.
« Última modificación: 30 Octubre 2010, 00:45 am por Khronos14 » En línea

Páginas: [1] 2 Ir Arriba Respuesta Imprimir 

Ir a:  
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines