Problem mit Prozedur (Integerprüfung) + Überladungen

[DieDolly]

Ich versuche gerade eine Prozedur zu schreiben der ich eine numerische Variable übergebe sowie einen Standard-, Minimal- und Maximalwert.
Befindet sich In nicht im Rahmen, wird der Standardwert zurückgegeben.
Das klappt auch aber ich bekomme es nicht hin das mit überladenen Prozeduren zu realisieren, sodass ich Int64, Integer und alle anderen übergeben kann.

Mein kläglicher Versuch. Kompiliert nicht mit dem Fehler, dass keine überladene Prozedur im zweiten Aufruf unten gefunden werden kann

Delphi-Quellcode:

type
 TIntUtils = record
 public
  class procedure CheckInteger(var IntToCheck: Int64; iDefaultValue: Int64; iMinValue: Int64; iMaxValue: Int64); overload; static;
  class procedure CheckInteger(var IntToCheck: Integer; iDefaultValue: Int64; iMinValue: Int64; iMaxValue: Int64); overload; static;
 end;

implementation

class procedure TIntUtils.CheckInteger(var IntToCheck: Int64; iDefaultValue: Int64; iMinValue: Int64; iMaxValue: Int64);
begin
 if (IntToCheck < iMinValue) or (IntToCheck > iMaxValue) then
  IntToCheck := iDefaultValue;
end;

class procedure TIntUtils.CheckInteger(var IntToCheck: Integer; iDefaultValue: Int64; iMinValue: Int64; iMaxValue: Int64);
begin
 CheckInteger(Int64(IntToCheck), iDefaultValue, iMinValue, iMaxValue);
end;

Der Aufruf sähe etwa so aus. Im Beispiel unten hätte die Variable X danach den Wert 123.

Delphi-Quellcode:

var X : Integer

X := 100;
TIntUtils.CheckInteger(X, 123, 110, 200)

Wie würdet ihr diese Prozedur schreiben?

[Der schöne Günther]

Zitat von DieDolly:

Wie würdet ihr diese Prozedur schreiben?

Ich würde die Unit System.Math für InRange(..) bzw. EnsureRange(..) verwenden


PS: Deine Fassung kompiliert nicht da du einen hart gecasteten Wert anscheinend nicht als var-Parameter übergeben kannst?

Richtig sähe es so aus

Delphi-Quellcode:

class procedure TIntUtils.CheckInteger(var IntToCheck: Integer; iDefaultValue: Int64; iMinValue: Int64; iMaxValue: Int64);
var
   asInt64: Int64;
begin
 asInt64 := Int64(IntToCheck);
 CheckInteger(asInt64, iDefaultValue, iMinValue, iMaxValue);
end;

PPS: Was macht es für einen Sinn einen Integer als Wert und einen Int64 als Default-Wert zu übergeben?

[DieDolly]

Weiß ich nicht. Auch deswegen bin ich hier und frage, wie es besser geht.

Delphi-Quellcode:

begin
 asInt64 := Int64(IntToCheck);
 CheckInteger(asInt64, iDefaultValue, iMinValue, iMaxValue);
end;

Da fehlt glaube ich noch IntToCheck := asInt64;

[KodeZwerg]

vielleicht so?

Delphi-Quellcode:

type
 TIntUtils = record
 public
  class procedure CheckInteger(var IntToCheck: Integer; const iDefaultValue, iMinValue, iMaxValue: Int64); overload; static;
  class procedure CheckInteger(var IntToCheck: Int64; const iDefaultValue, iMinValue, iMaxValue: Int64); overload; static;
 end;

implementation

uses
  System.Variants;

{$R *.dfm}

class procedure TIntUtils.CheckInteger(var IntToCheck: Int64; const iDefaultValue, iMinValue, iMaxValue: Int64);
begin
 if ((VarCompareValue(IntToCheck, iMinValue) = vrLessThan) or (VarCompareValue(IntToCheck, iMaxValue) = vrGreaterThan)) then
// if (IntToCheck < iMinValue) or (IntToCheck > iMaxValue) then
  IntToCheck := iDefaultValue;
end;

class procedure TIntUtils.CheckInteger(var IntToCheck: Integer; const iDefaultValue, iMinValue, iMaxValue: Int64);
var
   asInt64: Int64;
begin
 asInt64 := Int64(IntToCheck);
 CheckInteger(asInt64, iDefaultValue, iMinValue, iMaxValue);
 IntToCheck := Integer(asInt64);
end;

procedure TForm1.FormCreate(Sender: TObject);
var
 X: Integer;
 Y: Int64;
begin
  X := 1000;
  Y := 1000;
  Memo1.Lines.Clear;
  TIntUtils.CheckInteger(X, 123, 110, 200);
  TIntUtils.CheckInteger(Y, 123, 110, 200);
  Memo1.Lines.Add('X: '+IntToStr(X));
  Memo1.Lines.Add('Y: '+IntToStr(Y));
end;

edit
Hatte Variant Code vergessen zu kopieren.