überlauf bei eigenem Zahlentyp

[himitsu]

ich wollt nur nochmal dieses vorstellen ... von der Declaration etwas Overload,
aber in der Verwendung einfach (von Equal bis Subtract könnte man notfalls was weglassen, halt das, was nicht benötigt wird ... hier im Beispiel wird z.B. nur Implicit, Inc und Equal benötigt)

Delphi-Quellcode:

Type TStellung = 1..16;
  TStellungRec = Record
    Class Operator Implicit          (Value: TStellung):    TStellungRec;
    Class Operator Implicit          (Rec:   TStellungRec): TStellung;
    Class Operator Inc               (Rec:   TStellungRec): TStellungRec;
    Class Operator Dec               (Rec:   TStellungRec): TStellungRec;
    Class Operator Equal             (Oper1, Oper2: TStellungRec): Boolean;
    Class Operator NotEqual          (Oper1, Oper2: TStellungRec): Boolean;
    Class Operator LessThan          (Oper1, Oper2: TStellungRec): Boolean;
    Class Operator LessThanOrEqual   (Oper1, Oper2: TStellungRec): Boolean;
    Class Operator GreaterThan       (Oper1, Oper2: TStellungRec): Boolean;
    Class Operator GreaterThanOrEqual(Oper1, Oper2: TStellungRec): Boolean;
    Class Operator Add               (Oper1, Oper2: TStellungRec): TStellungRec;
    Class Operator Subtract          (Oper1, Oper2: TStellungRec): TStellungRec;
  Private
    Stellung: TStellung;
    Class Procedure RangeCheck       (Var Value: TStellung); Static;
  End;

Class Operator TStellungRec.Implicit(Value: TStellung): TStellungRec;
  Begin
    Result.Stellung := Value;
    RangeCheck(Result.Stellung);
  End;

Class Operator TStellungRec.Implicit(Rec: TStellungRec): TStellung;
  Begin
    Result := Rec.Stellung;
  End;

Class Operator TStellungRec.Inc(Rec: TStellungRec): TStellungRec;
  Begin
    Result.Stellung := Rec.Stellung;
    Inc(Result.Stellung);
    RangeCheck(Result.Stellung);
  End;

Class Operator TStellungRec.Dec(Rec: TStellungRec): TStellungRec;
  Begin
    Result.Stellung := Rec.Stellung;
    Dec(Result.Stellung);
    RangeCheck(Result.Stellung);
  End;

Class Operator TStellungRec.Equal(Oper1, Oper2: TStellungRec): Boolean;
  Begin
    Result := Oper1.Stellung = Oper2.Stellung;
  End;

Class Operator TStellungRec.NotEqual(Oper1, Oper2: TStellungRec): Boolean;
  Begin
    Result := Oper1.Stellung <> Oper2.Stellung;
  End;

Class Operator TStellungRec.LessThan(Oper1, Oper2: TStellungRec): Boolean;
  Begin
    Result := Oper1.Stellung < Oper2.Stellung;
  End;

Class Operator TStellungRec.LessThanOrEqual(Oper1, Oper2: TStellungRec): Boolean;
  Begin
    Result := Oper1.Stellung >= Oper2.Stellung;
  End;

Class Operator TStellungRec.GreaterThan(Oper1, Oper2: TStellungRec): Boolean;
  Begin
    Result := Oper1.Stellung > Oper2.Stellung;
  End;

Class Operator TStellungRec.GreaterThanOrEqual(Oper1, Oper2: TStellungRec): Boolean;
  Begin
    Result := Oper1.Stellung >= Oper2.Stellung;
  End;

Class Operator TStellungRec.Add(Oper1, Oper2: TStellungRec): TStellungRec;
  Begin
    Result := Oper1.Stellung + Oper2.Stellung;
    RangeCheck(Result.Stellung);
  End;

Class Operator TStellungRec.Subtract(Oper1, Oper2: TStellungRec): TStellungRec;
  Begin
    Result := Oper1.Stellung - Oper2.Stellung;
    RangeCheck(Result.Stellung);
  End;

Class Procedure TStellungRec.RangeCheck(Var Value: TStellung);
  Begin
    While Value <  Low(TStellung) do Value := Value + (High(TStellung) - Low(TStellung) + 1);
    While Value > High(TStellung) do Value := Value - (High(TStellung) - Low(TStellung) + 1);
  End;

Delphi-Quellcode:

Var Stellung: TStellungRec;

Begin
  Stellung := 14;
  Inc(Stellung);  // 15
  Inc(Stellung);  // 16
  Inc(Stellung);  // 1
  Inc(Stellung);  // 2
  If Stellung = 1 Then ;
End.

hier ließen sich dann ahc so Sachen wie
Type TStellung = (a=1, b=2, d=4, z=26); leicht lösen ... man muß dann nur die Berechnungen anpassen