[Lord Delfos]

Empezado por LuisAlf::

La verdad no se como es eso lo de OUT....si podrias explicarlo como funciona y como se manda a llamar tal procedimiento...

Bueno, habría que esperar a que ioco lo explique... pero le quiero ganar de mano y sumar otro post a mi favor

Hay dos maneras de pasar parámetros a un procedimiento/función:

[1] Por referencia (usando "var").
[2] Por valor (sin escribir nada).

Cuando uno pasa un parámetro por referencia, la variable que se pasa conserva el valor que se le haya dado adentro del procedimiento. Por ejemplo:

Código Delphi [-]
procedure HagoAlgo(var UnaVariable: Integer);
begin
  UnaVariable:= 22;
end;

var Pepito: Integer;

begin
  Pepito:= 4;
  HagoAlgo(Pepito);
  //Ahora Pepito vale 22.
end;

Al pasar por valor, en cambio, uno lo que pasa es una copia de la variable original. Así, si el procedimiento que la recibe la modifica, mi variable original no es modificada, porque lo que se modifica es una copia, no el original. Por ejemplo:

Código Delphi [-]
procedure HagoAlgo(UnaVariable: Integer); <-- sin el "var"
begin
  UnaVariable:= 22; <-- Modifica una copia de "Pepito", no el original.
end;

var Pepito: Integer;

begin
  Pepito:= 4;
  HagoAlgo(Pepito);
  //Pepito sigue valiendo 4.
end;

Ahora bien, en Delphi hay otros dos tipos de parámetros:

[1] El paso por constante (con la palabra "const").
[2] El paso por salida (con la palabra "out").

El paso por constante es útil para pasar algo que no queremos que se modifique (es decir, que pasaríamos por valor) pero que mide mucho como para dejar que el compilador haga una copia de la variable antes de pasarla. Al usar "const" lo que el compilador hace es pasar la variable original, pero controla que no se quiera hacer ninguna modificación. Por ejemplo:

Código Delphi [-]
procedure HagoAlgo(const UnaVariable: Integer);
begin
  UnaVariable:= 22; <-- Error de compilación, no se permite modificar la variable.
end;

Es útil cuando pasamos strings o arreglos, que son muy grandes como andar copiándolos. Hace al código más eficiente... por supuesto, siempre y cuando no quiéramos modificarlos.

El paso por salida sirve para indicar que lo que tenga la variable adentro es irrelevante y que se va a sobreescribir con otro valor. En sí es un paso por referencia (como con "var"), pero sirve para que el que use la función/procedimiento sepa que si hay algo en la variable, más vale que esté destruido antes de llamar a la función, sino las cosas pueden salir mal. Por ejemplo:

Código Delphi [-]
procedure HagoAlgo(out UnaVariable: TObject);
begin
  UnaVariable:= TObject.Create;
  UnaVariable.TalCosa:= 4;
end;

var Pepito: TObject;

begin
  //Hago mil cosas con Pepito
  HagoAlgo(Pepito);
  //La sonamos. HagoAlgo crea el objeto, pero mi variable Pepito ya estaba creada y entonces tengo un goteo de memoria, porque creé un objeto "arriba" de otro.
end;

Lo correcto sería:

begin
  //Hago mil cosas con Pepito
  Pepito.Free; <-- Destruyo pepito
  HagoAlgo(Pepito);
end;

Saludongos.