¿por que parametros opcionales function procedure no me funcionan?

[JXJ]

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


{
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;




// 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


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.



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

[roman]

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

[Delphius]

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

Parámetros por valor:
function Foo(Param: TDato): TOtroDato;
procedure Foo(Param: TDato);

Modo de uso:
algo2 := Foo(algo1);
Foo(algo3);

Parámetros por referencia:
Function Foo(var Param: TDato): TOtroDato;
procedure Foo(var Param: TDato);

Modo de uso:

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:

function Foo(Param1: TDato; var Param2: TDato = VALOR_DEFECTO): TOtroDato;
procedure Foo(Param1: TDato; var Param2: TDato = VALOR_DEFECTO);


Modo de uso:


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,

[duilioisola]

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

// 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);

[JXJ]

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.

// Saludos
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..

[Delphius]

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.

[Casimiro Notevi]

ahora si delphi me decepciono..

No entiendo en qué te ha decepcionado :confused:

[JXJ]

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

[roman]

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

[JXJ]

roman siempre tan equanime . .. :D