¿por que parametros opcionales function procedure no me funcionan?
 

hola

que tengo una rutina de codigo que quiero que 2 parametros sean opcionales.
var FechaInicial:TdateTime; var FechaFinal :TdateTime) : Integer;

y al usarla me sale conq eu me faltan esos 2 parametros que yo defini como opcionales

Código Delphi [-]
{
declaracion
}

   function ComprobanteImprime(UnicodEmisor :string; UnicodReceptor :string; UnicodSucursal :string; UnicodComprobante :string; TipoComprobante :string;
            var FechaInicial:TdateTime;  var FechaFinal :TdateTime) : Integer;
var

function TComprobanteCFDIClas.ComprobanteImprime(UnicodEmisor :string; UnicodReceptor :string; UnicodSucursal :string; UnicodComprobante :string; TipoComprobante :string;
         var FechaInicial:TdateTime;  var FechaFinal :TdateTime): Integer;
var
  PrintEngineF: TPrintEngineF;
begin
//lanzamos un form que se encargara de decidir que comprobante imrpimir
  PrintEngineF := TPrintEngineF.Create(Application);
end;

Código Delphi [-]
// utilizacion me exige los 2 parametros que puse como opcionaes que anda mal???

 CompCFDI.ComprobanteImprime(
                              CompCFDI.Emisor_CODIGO, CompCFDI.Receptor_CODIGO, CompCFDI.SUCURSALUNICCODE,
                              CompCFDI.CODIGO,  CompCFDI.TIPOCOMPROBANTE

                             );

por qu eel codigo de aqui
http://www.delphibasics.co.uk/RTL.asp?Name=BlockWrite

BlockWrite si es de 3 parametros pero en su declaracion es de 4

Código Delphi [-]
function  _BlockWrite(var f: TFileRec; buffer: Pointer; recCnt: Longint; var recsWritten: Longint): Longint;

var

function  _BlockWrite(var f: TFileRec; buffer: Pointer; recCnt: Longint; var recsWritten: Longint): Longint;
begin
  Result := BlockIO(f, buffer, recCnt, recsWritten, fmOutput,
  {$IFDEF MSWINDOWS} WriteFileX, {$ENDIF}
  {$IFDEF POSIX} __write, {$ENDIF}
  101);
end;

///

asi se supone que se usa.

Código Delphi [-]

var
  myFile    : File;
  byteArray : array[1..8] of byte;
  oneByte   : byte;
  i, count  : Integer;

 begin
  // Try to open the Test.byt file for writing to
  AssignFile(myFile, 'Test.byt');
  ReWrite(myFile, 4);   // Define a single 'record' as 4 bytes

  // Fill out the data array
  for i := 1 to 8 do
    byteArray[i] := i;

  // Write the data array to the file
  BlockWrite(myFile, byteArray, 2);   // Write 2 'records' of 4 bytes

En ningún momento estás definiendo los parámetros como opcionales. Eso se hace asignando un valor por defecto en el encabezado de la función. El caso de BlockWrite es distinto porque es una función "especial" que el compilador conoce cómo tratar, dependiendo del número de parámetros con que se invoque. En otras palabras, es una "trampa" de Delphi.

Agrego: Se me olvidaba. También puedes lograr el efecto de parámetros opcionales usando sobrecarga de funciones (overload).

// Saludos

Tal parece que tenemos oxidados los conocimientos más básicos del lenguaje, JXJ. IMPERDONABLE,

Parámetros por valor:

Código Delphi [-]
function Foo(Param: TDato): TOtroDato;
procedure Foo(Param: TDato);

Modo de uso:

Código Delphi [-]
algo2 := Foo(algo1);
Foo(algo3);

Parámetros por referencia:

Código Delphi [-]
Function Foo(var Param: TDato): TOtroDato;
procedure Foo(var Param: TDato);

Modo de uso:

Código Delphi [-]
algo2 := Foo(algo1);
// hacemos "algo" con algo1 para evaluar si ha tenido un cambio en su valor...

Foo(algo3);
// hacemos "algo" con algo3 para evaluar si ha tenido un cambio en su valor...

Parámetros opcionales o por defectos:

Código Delphi [-]
function Foo(Param1: TDato; var Param2: TDato = VALOR_DEFECTO): TOtroDato;
procedure Foo(Param1: TDato; var Param2: TDato = VALOR_DEFECTO);

Modo de uso:

Código Delphi [-]
algo := Foo(algo1);
algo := Foo(algo1, algo2);

Foo(algo3);
Foo(algo3, algo4);

La posibilidad de sobrecargar como comenta roman si bien puede resultar válida si lo vemos desde la unidad cliente, no es estrictamente hablando un caso de parámetros opcionales. En realidad son funciones sobrecargadas con diferente cantidad de parámetros; que no opcionales o por defecto.

Saludos,

Como nota final a lo que dice Delphius, me gustaría agregar que los parámetros opcionales siempre deben ser los últimos.

Código Delphi [-]
// Esto es correcto
function Foo(Param1: TDato; var Param2: TDato; Param3: TDato = VALOR_DEFECTO): TOtroDato;
procedure Foo(Param1: TDato; var Param2: TDato; Param3: TDato = VALOR_DEFECTO);

// Esto es INCORRECTO
function Foo(Param1: TDato; var Param2: TDato = VALOR_DEFECTO; Param3: TDato): TOtroDato;
procedure Foo(Param1: TDato; var Param2: TDato = VALOR_DEFECTO; Param3: TDato);

todo lo que me dijeron ya lo sabia menos lo que dijo roman..

gracias.. por su amable atencion. el asunto es qeu no queria usar overload ni nada de eso.

por que a mi parecer no me conviene hacerlo asi mejor hacer 2 funciones o procedures claramente
distintas en sus parametros. con nombre distintos.

ahora si delphi me decepciono..

Entonces no te has sabido explicar. Y si realmente a lo que se te ha dicho lo sabes, ¿cómo entonces no sabías de antemano que para declarar un parámetro como opcional o por defecto se debe indicar el valor?
Entonces tu pregunta no hubiera sido en ese sentido, y haber aportado de lleno en tu duda en como poder solventarlo.

Delphi no te ha decepcionado, eres tu mismo que no se sabe explicar por lo que no se entiende que es lo que buscas y culpas a Delphi de no poder lograrlo.

No entiendo en qué te ha decepcionado :confused:

función "especial" que el compilador conoce cómo tratar,

Pues bueno, en tal caso, la decepción debes remontarla hasta los orígenes de pascal. Las funciones Read y Write son claro ejemplo de funciones que el compilador trata de forma especial.

// Saludos

roman siempre tan equanime . .. :D