Programa Facil Con Delphi7

Consulta de Fechas con un adoquery

noreply@blogger.com (Erick Mueses) — Mon, 9 Mar 2009 13:50:00 -0400

datamodule2.ADOQueryrepresultados.Close;
   datamodule2.ADOQueryrepresultados.SQL.Clear;
   datamodule2.ADOQueryrepresultados.SQL.Add('Select * from resultados_emitidos,pacientes,convenios');
   datamodule2.ADOQueryrepresultados.SQL.Add('where resultados_emitidos.cedula_paciente=pacientes.cedula');
   datamodule2.ADOQueryrepresultados.SQL.Add('and resultados_emitidos.codigo_convenio = convenios.codigo');
   datamodule2.ADOQueryrepresultados.SQL.Add('and fecha1 >= :fecha_emision and fecha2<= :fecha2');
   datamodule2.ADOQuery1.Parameters.ParamByName('fecha1').value := DateTimePicker1.Date;
   datamodule2.ADOQuery1.Parameters.ParamByName('fecha2').value := DateTimePicker2.Date;
   datamodule2.ADOQueryrepresultados.Open;

Cómo enviar E-mail con el cliente de correo electrónico por defecto desde Delphi

noreply@blogger.com (Erick Mueses) — Wed, 4 Feb 2009 16:05:00 -0400

¿Cómo puedo enviar un E-Mail desde Delphi usando el cliente de correo electrónico por defecto instalado en tu pc (Outlook por ejemplo) si no tengo un navegador instalado?, pues es muy sencillo, utilizando un TMemo generamos el siguiente código:

uses   ShellAPI, Windows;
...
ShellExecute(0, 'open', PChar('mailto:bugreports@youremail.com?subject=
Bug%20Report&Body=' + MemoBugText.Text),   nil, nil, SW_SHOWNORMAL);

Numeros aleatorios sin repeticion (una clase)

noreply@blogger.com (Erick Mueses) — Wed, 15 Oct 2008 16:55:00 -0400

Supongamos que tenemos que rellenar una lotería primitiva: tenemos que hallar 6 números aleatorios de entre 69 números pero sin que se repitan.
¿Como lo hacemos?, pues nada, aplicando la clase contenida en este truco.
En concreto acabo de hacer esto pues estoy haciendo una página web y necesito mostrar en la misma página 3 artículos aleatorios de una base de datos... y claro, que se me repitan en la misma página web 3 articulos no es muy estético que digamos...
Como en el asunto este se mezclan datos y funciones y procedures, he decidido meterlo todo en una clase para facilitar su reutilización.
He colocado todo en una unit, (llamada uTAlea) para que con sólo añadirla en la clausula uses de nuestra aplicación pueda ser utillizada.
Aqui está el código de la unit uTAlea que contiene la clase TAlea:

 unit uTAlea;
 {Radikal, Q3 para Trucomania.}

 interface

 uses Windows,SysUtils;

 type
   {Array de booleanos de longitud variable}
   TArrayBool = array[0..0] of boolean;
   PArrayBool = ^TArrayBool;

   {Clase para manejar numeros aleatorios}
   TAlea = class
     Maximo             : integer;            //Valor maximo de los numeros obtenidos
     Lista              : PArrayBool;
     FaltanDeSacar      : integer;
     constructor        Create(Rango:integer);
     destructor         Destroy; override;
     procedure          Reset;                //Resetea la lista de numeros
     function           PillaNumero:integer;  //Devuelve un numero aletorio sin repeticion
   end;



 implementation


 constructor TAlea.Create(Rango:integer);
 begin
 {
   Si los números a extraer no pueden ser repetidos
   hemos de crear un array para almacenar cual ha salido y cual no
   Como el array ha de ser variable, usamos el GetMem y
   los punteros para que sirva tambien para versiones
   anteriores a Delphi 4, que no incorporan los arrays
   de longitud variable...
 }
   inherited Create;
   Maximo:=Rango;
   FaltanDeSacar:=Rango;
   {Reservamos memoria para el array de longitud variable}
   GetMem(Lista, 1+Maximo * SizeOf(Boolean));
   ZeroMemory(Lista,1+Maximo * SizeOf(Boolean));
 end;

 destructor TAlea.Destroy;
 begin
   if Assigned(Lista) then FreeMem(Lista, 1+Maximo * SizeOf(Boolean));
   inherited Destroy;
 end;

 function TAlea.PillaNumero:integer;
 var
   Numero: integer;
 begin
   if FaltanDeSacar=0 then raise exception.create( 'Error. No se pude sacar otro numero sin repetir'+#13+#10+
                                                   'Error. No more numbers are available');

   {Buscamos un número que no haya salido ya}
   repeat Numero:=Random(Maximo) until NOT Lista^[Numero];
   {Lo apuntamos en la lista de numeros ya usados}
   Lista^[Numero]:=TRUE;
   {Decrementamos la cantidad de numeros que faltan por salir}
   Dec(FaltanDeSacar);
   Result:=Numero;
 end;

 procedure TAlea.Reset;
 begin
   ZeroMemory(Lista,1+Maximo * SizeOf(Boolean));
   FaltanDeSacar:=Maximo;
 end;

 end.

Ya sabes, la grabas como uTAlea.PAS para poder usarla en tus proyectos.
Vamos con una aplicación de ejemplo para probar la clase:

Crea una aplicacion nueva, con una form que contenga un TMemo (Memo1) y un TButton (Button1)

Copia el uTAlea.PAS en el directorio de esa aplicacion

Añade TAlea en el uses de tu form

Mete el siguiente código en el OnCLick del Button1:

 procedure TForm1.Button1Click(Sender: TObject);
 var
   Ristra : TAlea;
   n      : integer;
 begin
    Memo1.Lines.Clear;

    Ristra:=TAlea.Create(10);

    {Sacamos 10 numero sin repetir}
    for n:=1 to 10 do begin
      memo1.Lines.Add( IntToStr(Ristra.PillaNumero) );
    end;

    Memo1.lines.Add('Otros 5 numeros de entre 10...');

    Ristra.Reset;
    for n:=1 to 5 do begin
      memo1.Lines.Add( IntToStr(Ristra.PillaNumero) );
    end;

    Ristra.Free;
 end;

Calcular la Edad (en años) segun la fecha de nacimiento

noreply@blogger.com (Erick Mueses) — Wed, 15 Oct 2008 16:51:00 -0400

procedure TForm1.Button1Click(Sender: TObject);

   function Edad(FechaNacimiento:string):integer;
   var
      iTemp,iTemp2,Nada:word;
      Fecha:TDate;
   begin
     Fecha:=StrToDate(FechaNacimiento);
     DecodeDate(Date,itemp,Nada,Nada);
     DecodeDate(Fecha,itemp2,Nada,Nada);
      if FormatDateTime('mmdd',Date) <
         FormatDateTime('mmdd',Fecha) then Result:=iTemp-iTemp2-1
                                      else Result:=iTemp-iTemp2;
   end;

 begin
   Label1.Caption:=intToStr(Edad('07/09/1969'));
 end;

Mantener una Spash Screen unos segundos tras cargar la aplicación

noreply@blogger.com (Erick Mueses) — Wed, 15 Oct 2008 16:45:00 -0400

En tu form principal, declara una variable pública llamada SplashScreenHandle:

 	var
 	    SplashScreenHandle:integer;

En el fuente del projecto, añade una sección var como la siguiente:

 	VAR
 	    SplashScreen:TSplashScreen;

Dentro de la sección begin-end, añade el siguiente código al principio:

 Begin
     {Mostramos la Splash Screen}
     {Show the splash screen}
     SplashScreen:=TSplashScreen.Create(Application);
     Splashscreen.show;
     SplashScreen.update;
     {Creamos la form principal}
     {Create the main form}
     Application.createform(MainForm,MainFormUnit);
     MainFormUnit.SplashScreenHandle:=SplashScreen.handle;
     {Aqui el resto de tu projecto...}
     {rest of your code goes here....}
 end.

Entonces, en tu form principal, mediante un timer, ejecutamos éste código para cerrar la Splash Screen:

     SendMessage(SplashScreenHandle,WM_CLOSE,0,0);

Agilizar la carga de tu aplicacion

noreply@blogger.com (Erick Mueses) — Wed, 15 Oct 2008 16:41:00 -0400

¿ Tu aplicacion tarda mucho en cargar ?. Igual te interesa este truco...

No crees todos los forms de golpe, crea sólo el inicial, y desde el crea dinámicamente los que vayas a utilizar, sólo cuando los vayas a utilizar. Es decir, en el IDE, en Project->Options tienes dos ventanas, una la de 'Autocreate forms' y otra, la de 'Available forms'. Pues pon sólo la principal en 'Autocreate forms'.

Después, en el uses de la primera form, añades las units del resto de forms, y en el var de la primera form, declaras las variables TForm del resto de forms que vayas a crear.

Un ejemplo de Form1 que crea una Form2:

El uses de Form1:

 uses
   Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,  StdCtrls, Unit2;

El var de Form1:

 var
   Form1: TForm1;
   Form2: TForm2;

Y cuando quieras llamar a la Form2 desde Form1 usa:

 procedure TForm1.Button1Click(Sender: TObject);
 begin
   Form2:=TForm2.Create(self);
   Form2.Show;
 end;

Si tras hacer todo esto, te sigue tardando mucho en cargar el primer form, puedes ponerle una Splash Screen (una pantalla inicial) en la que le pones el típico mensaje de 'cargando'.

SplashScreen con progressbar

noreply@blogger.com (Erick Mueses) — Wed, 15 Oct 2008 16:30:00 -0400

Hacer que aparezca una ventana mientras se carga mi aplicacion (Splash Screen)
se explica cómo hacer una SplashScreen.
"SplashScreen con progressbar", esta pensado sobre todo para cuando abres bases de datos y se tarda un mundo en cargar el programa. Con el progressbar queda bastante bien...
Primero debemos definir cuantos "pasos" va a tener el progressbar, en este caso el numero de bases de datos que vamos a abrir, luego establecemos por ejemplo el valor Max progressbar a 40 y el valor Step a 10 y hacemos 4 "stepit", seria de la siguiente manera:
Este codigo esta en el evento OnCreate de una form principal, pero podriamos mandarlo llamar de otras forms siempre en el evento OnCreate.

 procedure TForm1.FormCreate(Sender: TObject);

 begin
   Try
     DataBase1.Connected:=True
   Except
     ShowMessage('Cannot open DB1')
   End;
   SplashForm.ProgressBar.StepIt;
   SplashForm.update;
   Try
     DataBase2.Connected:=True
   Except
     ShowMessage('Cannot open DB2')
   End;
   SplashForm.ProgressBar.StepIt;
   SplashForm.update;
   Try
     Table1.Active:=True
   Except
     ShowMessage('Cannot open Table 1')
   End;
   SplashForm.ProgressBar.StepIt;
   SplashForm.update;
   Try
     Table2.Connected:=True
   Except
     ShowMessage('Cannot open Table 2')
   End;
   SplashForm.ProgressBar.StepIt;
   SplashForm.update;
   ...
   SplashForm.Free
 end;

Ventajas de migrar de Delphi 7 a Delphi 2007 for Win32 Part. 1

noreply@blogger.com (Erick Mueses) — Thu, 7 Aug 2008 10:34:00 -0400

Muchos desarrolladores que utilizan la versión 7 se Delphi preguntan cuales son las razones para cambiar a una nueva versión de Delphi, en este momento la mas nueva versión de Delphi 2007 para Win32, exclusivamente para desarrollo nativo – Win32. Como las discusiones sobre el asunto se extienden, vamos a presentar, en este articulo, las principales razones para hacer esta migración, presentando todos los nuevos recursos desde la versión de Delphi 7.

Continuamos buscando mas calidad y mejor desempeño en el IDE y las aplicaciones generadas, con Delphi 2007 for Win32 tenderás mas desempeño en tiempo de desarrollo y en la aplicación final comparado a Delphi 7.

Novedades en el compilador y el lenguaje desde Delphi 7

Directiva inline

Se trata de una nueva directiva que va aumentar el desempeño del compilador con solo agregar la palabra reservada “inline”. En este caso, el método es expandido, evitando su lectura a todo momento. Esta forma de acceso presenta mejores resultados para métodos pequeños, fuera del alcance de la unit o para rutinas con muchos parámetros. Para el caso de rutinas mas grandes, se recomienda hacer una análisis de costo-benefició en cuanto a su utilización

A continuación se muestra el código una aplicación de consola, utilizando “inline” en la función Max.

program InlineDemo;
{$APPTYPE CONSOLE}

uses
MMSystem;

function Max(const X,Y,Z: Integer): Integer;inline
begin
    if X > Y then
      if X > Z then Result := X
               else Result := Z
    else
      if Y > Z then Result := Y
               else Result := Z
end;

const
Times = 10000000; // 10 millón
var
A,B,C,D: Integer;
Start: LongInt;
i: Integer;

begin
Random; // 0
A := Random(4242);
B := Random(4242);
C := Random(4242);
Start := TimeGetTime;
for i:=1 to Times do
D := Max(A,B,C);
Start := TimeGetTime-Start;
writeln(A,', ',B,', ',C,': ',D);
writeln('Calling Max ',Times,' times took ',Start,' milliseconds.');
readln

end.

Al ejecutar esté código y comparar los resultados se encuentra una reducción importante en el tiempo de respuesta. Los siguientes resultados se obtuvieron después de que se ejecutó la función Max 10 millones de veces en una computadora Pentium M 1.8GHz con 2GB RAM. . Aunque estos valores pueden cambiar una computadora a otra, las proporciones son similares.

Con inline	Sin inline
25 milisegundos	68 milisegundos

De acuerdo con lo visto en la tabla anterior, se observa que al utilizar la capacidad “inline”, el código compilado puede aumentar, su rendimiento más de un 50%.

Sobrecarga de operadores

type
   TMyClass = class
     class operator Sumar(a, b: TMyClass): TMyClass;      // Sumar las clases de tipo TMyClass
     class operator Restar(a, b: TMyClass): TMyclass; // Restar las clases de tipo TMyClass
     class operator Implicit(a: Integer): TMyClass;     // Conversión implícita para la clase de tipo TMyClass
     class operator Implicit(a: TMyClass): Integer;     // Conversión implícita de la clase TmyClass para Integers.
     class operator Explicit(a: Double): TMyClass;      // Conversión explicita de un Double para la clase TMyClass
   end;

// Ejemplo de implementación del método Sumar
class operator TMyClass.Add(a, b: TMyClass): TMyClass;
begin
// ...
end;

var
x, y: TMyClass;
begin
   x := 12;      // Conversión implícita de un Integer, ejecuta el método Implicit
   y := x + x;   // Ejecuta TMyClass.Add(a, b: TMyClass): TMyClass
   b := b + 100; // Ejecuta TMyClass.Add(b, TMyClass.Implicit(100))
end;

Class Helpers

Los Class Helpers permiten extender clases sin utilizar herencia. Este recurso es importante, pues algunas clases, llamadas clases Selead, no pueden ser heredadas. La utilización de este nuevo recurso es muy apreciada. A continuación se muestra un ejemplo.

type
   TMyClass = class
      procedure MyProc;
      function MyFunc: Integer;
   end;

...

   procedure TMyClass.MyProc;
   var X: Integer;
   begin
      X := MyFunc;
   end;

   function TMyClass.MyFunc: Integer;
   begin
       ...
   end;

...

type
   TMyClassHelper = class helper for TMyClass
     procedure HelloWorld;
     function MyFunc: Integer;
   end;

...

   procedure TMyClassHelper.HelloWorld;
   begin
      writeln(Self.ClassName); // Self hace referencia al tipo TMyClass y no TMyClassHelper
   end;

   function TMyClassHelper.MyFunc: Integer;
   begin
     ...
   end;
...
var
X: TMyClass;
begin
X := TMyClass.Create;
X.MyProc;    // Ejecuta TMyClass.MyProc
X.HelloWorld; // Ejecuta TMyClassHelper.HelloWorld
X.MyFunc;    // Ejecuta TMyClassHelper.MyFunc

Vale la pena observar que la referencia es siempre a la clase TMyClass. El compilador sabe cuando ejecutar la llamada a TMyClassHelper.

Strict private y Strict protected

Ahora en Delphi Win32 y .NET se tienen dos formas adicionales de determinar la visibilidad de los atributos de una clase: strict private y strict protected.

Strict private: todos los atributos de la clase son visibles únicamente en la clase que fueron declarados. Estos atributos no estarán visibles para métodos declarados en la misma unit y para aquellos que no forman parte de la clase.

Strict protected: Específica que los atributos da clase son visibles para la propia clase y sus descendentes.

Los Records ahora soportan métodos

Las capacidades de los registros (records) han sido incrementadas, pasando a ser casi lo mismo que una clase (Class), con soporte ha:
Constructores.
Sobre posición de operadores.
Declaración de métodos no-virtuales.
Métodos y propiedades estáticos.

Veamos un ejemplo de la implementación de un registro con estas nuevas características:

Type
    TMiRegistro = Record
    Type
         TTipoColor = Integer;
    Var
         Rojo : Integer;
         Class Var
         Azul : Integer;
         Procedure imprimirRojo();
Constructor Create(Val : Integer);
         Property pRojo : TTipoColor Read Rojo Write Rojo;
         Class Property pAzul : TTipoColor Read Azul Write Azul;
    End;

Constructor TMiRegistro.Create(Val: Integer);
Begin
Rojo := Val;
End;

Procedure TMiRegistro.imprimirRojo;
Begin
WriteLn('Rojo: ', Rojo);
End;

De acuerdo a lo visto anteriormente los registros pueden utilizar muchas de las funcionalidades que hasta entonces eran exclusivas de las clases, sin embargo los registros no son clases y tienen muchas diferencias:
Los Registros no tienen soporte a herencia;
Los Registros pueden tener partes variable, las clases no;
Los Registros son tipos de datos y pueden, entre otras cosas, ser copiados, clases no;
Los Registros no tienen destructores;
Los Registros no tienen soporte a métodos virtuales;

Class abstract, Class sealed, Class const, Class type, Class var, Class property

Diversas nuevas formas de declaración de clases, tipos, variables y propiedades.

Class abstract -Especifica una clase abstracta.

Class sealed - Especifica que la clase no puede ser heredada.

Class const - Especifica una constante para la clase, que puede ser accedida sin necesidad de crear instancias de la clase.

Class type -Define uno tipo para la clase que puede ser accedida sin necesidad de crear instancias de la clase.

Class var -Define una variable en el scope de la clase que puede ser accedida sin necesidad de crear instancias de la clase.

Class property -Define propiedad que puede ser accedida sin la necesidad de crear instancias de la clase.

Nested Clases

De una forma más didáctica, las clases Nested (o anidadas) serian como subclases, que pueden ser accedidas a partir de una clase y su tipo declarado dentro del contexto. Ejemplo de clase:

type
      TOuterClass = class
       strict private
          myField: Integer;
       public
          type
             TInnerClass = class
              public
                myInnerField: Integer;
                procedure innerProc;
             end;

procedure outerProc;
end;

El método de la clase interna se implementa de la siguiente manera:

procedure TOuterClass.TInnerClass.innerProc;
begin
...
end;

Finalmente el siguiente código muestra como acceder al método que está en la clase anidada:

var
x: TOuterClass;
y: TOuterClass.TInnerClass;

begin
   x := TOuterClass.Create;
   x.outerProc;
   ...
   y := TOuterClass.TInnerClass.Create;

Métodos finales

Los Métodos declarados con final especifican que el mismo método no pode ser sobrepuesto (override) en clases descendentes, sin embargo se puede declarar uno método con el mismo nombre siendo virtual.

Static class method

Son clases que cuando son declaradas como Static no necesitan ser instanciadas para ser accedidas.

For … in

Ahora es posible hacer un for directo en objetos que contengan collections, arrays, expresiones string y expresiones de tipo set, tanto para Delphi Win32 como para .NET. Ejemplos:

Ejemplo: Iteración en un Array

var
IArray1: array[0..9] of Integer = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
I: Integer;

begin
for I in IArray1 do
     begin
         // Hacer algo aquí...
     end;

Ejemplo: iteración en un String:

var
C: Char;
S1, S2: String;

OS1, OS2: ShortString;
AC: AnsiChar;
begin

S1 := ‘Nuevos recursos en Delphi 2007';
S2 := '';

for C in S1 do
S2 := S2 + C;

if S1 = S2 then
WriteLn('SUCESSO #1');
else
WriteLn('FALHOU #1');

OS1 := 'Migrando de Delphi 7 para Delphi 2007...';
OS2 := '';

for AC in OS1 do
OS2 := OS2 + AC;

if OS1 = OS2 then
WriteLn('EXITO #2');
else
WriteLn('FALLOU #2');

end.

Novedades en el IDE desde Delphi 7

El IDE trae una serie de novedades, como:

MSBuild à controle todo el proceso de compilación de su aplicación, los pasos antes y después de compilar un proyecto, esto es excelente para los desarrolladores que necesitan automatizar la compilación. Cuando abrir un proyecto en Delphi 2007, automáticamente el mismo va ser convertido para el nuevo formato y con la extensión DPROJ, para soportar MSBuild.

Vista e XP Themes à el IDE soporta los temas para Windows Vista y XP. Ahora es default y puedes habilitar y deshabilitar a través de las opciones de proyecto.

Project Manager à el project manager soporta múltiplas selecciones y con esto permite abertura, grabación y borrar mas de un archivo simultáneamente.

File Browser à con el File Browser no tenemos que abrir Windows Explorer o ir al menú File Open todo tiempo para abrir un archivo, pues File Browser ofrece acceso directo a su árbore de carpetas de dentro del IDE.

Live Templates, Block Completion, indicador de líneas alteradas

Los nuevos recursos de live template extienden la capacidad de crear plantillas de código en Delphi. Estas plantillas son creadas en un archivo XML y ayudan a programar escribiendo menos código.

Figure 1. Creando un try..finally utilizando la capacidad de LiveTemplates.

La capacidad de block completion es uno de los recursos que habilitan el begin y end automático. ¿Quién nunca se perdió con begin y end?

En la figura 1, tenemos una marcación amarilla y otra verde, la amarilla representa las líneas que fueron cambiadas, mientras las verdes son líneas que no cambiaran.

Histórico de los cambios

Independiente de una herramienta de control de versiones, las alteraciones en fuentes son versionadas localmente, permitiendo la comparación entre las versiones.

Figura 2. Versionamento local y comparación entre 2 fuentes

Depurador

El nuevo depurador trae diversas mejoras en variables locales, call stack y otros, sin embargo una de las principales novedades es la visualización en árboles. Véase un ejemplo:

Figura 3. Depurando una aplicación y visualizando las variables en TreeView

También es posible configurar la barra de enrollamiento de la ventana de eventos y abrir separadamente cada ítem de la ventana de CPU, con un simples drag-and-drop presionando la tecla CTRL, la ventana se queda transparente, facilitando la lectura del código durante la depuración.

Refactoring

Esta es una de las capacidades que más les gustan a los usuarios de Delphi 7, ya que a través de los refactorings se pueden renombrar clases, variables y métodos de manera que al hacer un cambio de nombre se cambien automáticamente todas las líneas de código en los que se hacía referencia al nombre anterior. Mediante esta capacidad de refactoring es posible también cambiar los parámetros de clases, seleccionar parte del código y generar un método a partir del bloque seleccionado, también es posible mover métodos de una clase a otra, entre muchas otras cosas.

Unidades de Prueba

La integración con unidades de pruebas a través de DUnit facilitan la creación de métodos y en general código de pruebas que se usa para probar el código de la propia aplicación. Esto facilita la notablemente la prueba de las aplicaciones, pues es como si se tuviese un “programa que prueba al programa”.

SQL Window - Query Builder

Ahora a través del DataExplorer podemos construir querys visualmente utilizando el Query Builder, desde simples sentencias select hasta complejos querys utilizando joins.

Figure 4 SQL Window integrado a Query Builder

PROCEDIMIENTOS Y FUNCIONES

noreply@blogger.com (Erick Mueses) — Tue, 15 Jul 2008 14:28:00 -0400

Delphi, es un lenguaje estructurado, lo cual indica que los programas escritos en este lenguaje, pueden descomponerse en pequeños módulos que pueden ser llamados cuando los necesitemos. Estos módulos en Pascal se llaman funciones y se identifican mediante un nombre. Se declaran del siguiente modo:

function nombre (argumento1: tipo; argumento2: tipo;...) : tipo;
Begin
/Acciones a realizar/
End;

Donde nombre es el nombre que se asignará a la función, argumento1 y argumento2 son valores que pasan a la función y tipo es el tipo de valor que retornará como resultado. Por ejemplo, si queremos implementar en Pascal la función matemática: f(x, y) = (x * x + y) / x siendo x e y números enteros, se realizaría de este modo:

Function f (x: integer; y: integer) : integer;
Begin
F = (x * x + y) / x;
End;

Dicha función, se definirá una sola ocasión durante el programa, y únicamente será necesario hacer llamada a esta función mediante su nombre y sus valores dados entre paréntesis.

a := f(1, 2); {llamada a f con x=1 e y=2}
b := f(a, 3); {llamada a f con x=a e y=3}
c := f(a, b) + f(1, 4);

Los valores colocados entre paréntesis de la función, reciben el nombre de argumentos. Estos se comportan dentro de la función, como si se tratase de variables.

PROCEDIMIENTOS

Toda función que no retorna valores ningún valor, o que no realiza operaciones matemáticas o genera resultados numéricos, recibe el nombre de procedimiento. La programación estructurada, se basa en dividirse en pequeñas partes autosuficientes que realizan una tarea muy concreta, y que pueden ser invocados cuando se desee. Se puede realizar alguna función o tarea especifica que arroje información de modo no numérico, o sin realizar operaciones, es entonces cuando se utilizan los procedimientos.

Un procedimiento se declara del mismo modo que una función, a diferencia que la palabra reservada Function cambia por Procedure y al final de la lista de argumentos no se pone ningún tipo de valor de respuesta, pues no arroja ningún resultado. Ejemplo:

Program Ejemplo2;
Procedure Di (mensaje: String);
Begin
Showmessage(mensaje);
End;
Begin
Di (‘Mi nombre es: ’);
Di (‘David Osornio Fernández’);
End;

También es posible construir funciones o procedimientos que no tengas argumentos, pues pueden realizar una tarea concreta, no importando alguna otra cosa. Ejemplo:

Program Ejemplo3;
Procedure Saluda;
Begin
Showmessage(‘Hola a todos’);
End;
Procedure Nombre;
Begin
Showmessage(‘Mi nombre es David Osornio Fernández’);
End;
Procedure Despidete;
Begin
Showmessage(‘Adiós a todos’);
End;
Saluda;
Nombre;
Despidete;
End;

SELECCIÓN MULTIPLE

noreply@blogger.com (Erick Mueses) — Tue, 15 Jul 2008 14:21:00 -0400

Cuando se realiza un programa, es frecuente encontrarse con alguna variable que según su valor realizara alguna acción. Esto se podría realizar con muchos If´s anidados, pero resultaria algo enredado, por ejemplo: Si se desea que cuando a tenga el valor 1, c tome el valor 10, cuando a tenga el valor 2, c tome el valor 15, cuando a tenga el valor 3, c tome el valor 20 y cuando no sea alguno de los 3 valores, entonces que c tome el valor 0:

If a = 1 then c := 10 Else

If a = 2 then c := 15 Else

If a = 3 then c := 20 Else

c := 0;

Esta forma de tomar decisiones resulta muy poco ortodoxa. El lenguaje Pascal nos ofrece para dicho propósito otra forma mas fácil de hacerlo. Mediante la palabra reservada case of. La sintaxis de dicha instrucción es la siguiente.

case variable of

valor1: acción1;

valor2: acción2;

....

Else acción N;

End;

Donde variable es el identificador de la variable que será comprobada y valor1, valor2... son los diferentes valores que puede tomar dicha variable. Si tomamos el problema anteriormente planteado, tendremos que la solución sería de este modo:

case a of

1: c := 10;

2: c := 15;

3: c := 20;

Else c:= 0;

End;

ANIDAMIENTOS

noreply@blogger.com (Erick Mueses) — Tue, 15 Jul 2008 14:10:00 -0400

Es sabido que después de la palabra reservada Then se pueden ejecutar secuencias de instrucciones las cuales pueden ser de cualquier tipo, ahora bien, ¿Es posible colocar un if dentro del bloque then de otro?. La respuesta es si, a estas sentencias de “If´s” encadenados se le denomina anidamiento.

El punto clave es tomar en cuenta que cuando se coloquen anidamientos es recomendable colocar las instrucciones Begin y End entre Then y Else de este modo sabremos exactamente a que if pertenece cada Else. Ejemplo:

If a = 7 then

Begin

If b = 2 then

c := 3

Else

c := 2

End

Else

c := 1;

Redondeo y dolores de cabeza

noreply@blogger.com (Erick Mueses) — Fri, 4 Jul 2008 12:54:00 -0400

La clásica función Round de Delphi y las más recientes funciones RoundTo se proyectan sobre algoritmos de redondeo de la CPU y la FPU. De manera predeterminada, las CPU de Intel utilizan el redondeo bancario, que es también el tipo de redondeo que se suele encontrar en aplicaciones de hojas de cálculo.

El redondeo bancario se basa en la suposición de que cuando se redondean números que residen exactamente entre dos valores (10s números ,5), a1 redondearlos arriba o abajo se aumenta o reduce estadisticarnente la cantidad total (en general de capital). Por este motivo, la regla del redondeo bancario indica que 10s números ,5 deberían redondearse arriba o abajo dependiendo de que el número (sin decimales) sea impar o par. De esta manera, el redondeo se equilibrara, a1 menos estadísticamente.

El ejernplo de redondeo de la figura, dernuestra el redondeo bancario y el aritmetico.

El programa tambidn utiliza otro tipo de redondeo proporcionado por la unidad Math mediante la funcion SimpleRoundTo, que utiliza un redondeo aritmktico asimetrico.

En este caso, todos 10s numeros ,5 se redondean a1 valor superior. Sin embargo, tal y como se recalca en el ejemplo de redondeo, la funcion no actua como se esperaria cuando se redondea hasta un digito decimal (es decir, cuando se pasa un segundo parametro negativo). En este caso, debido a 10s errores de representacion de 10s numeros de coma flotante, el redondeo recorta 10s valores; por ejemplo convierte 1,15 en 1,l en lugar del esperado 1.2. La solucion es multiplicar el valor por diez antes de redondear, redondearlos hasta cero digitos decimales, y despues dividirlo, como se muestra a continuacion:

(SimpleRoundTo ( d *10 , 0) / 10 )

Ejecutar Una Aplicacion Externa a Delphi

noreply@blogger.com (Erick Mueses) — Mon, 16 Jun 2008 11:24:00 -0400

Algunas veces cuando estamos programando hemos pensado o tenido la necesidad de llamar una aplicacion ya creada que este en el directorio de nuestro computador.

Pues aqui esta la solucion.

Lo unico que nececitamos hacer es poner el siguiente codigo en el boton o evento desde el cual se quiera llamar la aplicacion:

WinExec(PChar('c:\directorio\aplicacion.exe'),SW_SHOWNORMAL);

Donde 'c:\directorio\aplicacion.exe' es el directorio deonde se encuentra ubicada la aplicacion que necesitamos o queremos llamar para lo que sea que fuese necesario.

Un Poco de Historia

noreply@blogger.com (Erick Mueses) — Fri, 13 Jun 2008 15:38:00 -0400

Algunas de las propiedades originales de Delphi que atrajeron fueron su enfoque orientado a objetos y basado en formularios, su compilador extremadamente rápido, su gran soporte para bases de datos, su estrecha integración con la programación para Windows y su tecnología de componentes. Pero el elemento mas importante era el lenguaje Pascal orientado a objetos, que es la base de todo lo demás.

¡Delphi 2 era incluso mejor! Entre sus propiedades añadidas mas importantes estaban las siguientes: El Multi Record Object y la cuadricula para bases de datos mejorada, el soporte para Automatización OLE y el tipo de datos variantes, el soporte e integración totales de Windows 95, el tip0 de datos de cadena larga y la herencia de formulario visual. Delphi 3 añadió la tecnología Code Insight, el soporte de depuración DLL, las plantillas de componentes, el Teechart, el Decisión Cube, la tecnología WebBroker, los paquetes de componentes, los ActiveForms y una sorprendente integración con COM, gracias a las interfaces.

Delphi 4 nos trajo el editor AppBrowser, nuevas propiedades de Windows 98, mejor soporte OLE y COM, componentes de bases de datos ampliados y muchas mas clases principales de la VCL añadidas, como el soporte para acoplamiento, restricción y anclaje de los controles. Delphi 5 añadió a este cuadro muchas mejoras en el IDE (demasiadas para enumerarlas aquí), soporte ampliado para bases de datos (con conjuntos de datos específicos de ADO e InterBase), una versión mejorada de MIDAS con soporte para Internet, la herramienta de control de versiones Teamsource, capacidades de traducción, el concept0 de marcos y nuevos componentes.

Delphi 6 añadió a todas estas propiedades el soporte para el desarrollo multiplataforma con la nueva biblioteca de componentes para multiplataforma (CLX), una biblioteca en tiempo de ejecución ampliada, el motor para base de datos dbExpress, un soporte excepcional de servicios Web y XML, un poderoso marco de trabajo de desarrollo Web, mas mejoras en el IDE y multitud de componentes y clases.

Delphi 7 proporciono mas robustez a estas nuevas tecnologías con mejoras y arreglos (el soporte de SOAP y DataSnap es lo primer0 en lo que puedo pensar) y ofrece soporte para tecnologías mas novedosas (como los temas de Windows XP o UDDI), pero lo mas importante es que permite disponer rápidamente de un interesante conjunto de herramientas de terceras partes: el motor de generación de informes RAVE, la tecnología de desarrollo de aplicaciones Web IntraWeb y el entorno de diseño ModelMaker. Finalmente, abre las puertas aun mundo nuevo al ofrecer (aunque sea como prueba) el primer compilador de Borland para el lenguaje PascallDelphi no orientado a la CPU de Intel, si no a la plataforma CIL de .NET.