Beschränkter Bereich für Variable

[nupset]

Hallo,
ich möchte gerne eine Variable haben, die nur die Werte von 1 bis 3 annehmen kann. Das ist wahrscheinlich gar nicht sonderlich schwierig, aber jetzt kommts :-D
Sollte der Wert außerhalb des Bereiches liegen, dann soll er automatisch... bäh. Mir fehlen die Worte...
also

Delphi-Quellcode:

variable:=3;
variable:=variable+1;
// Soll jetzt nicht 4 sein, sondern bei eins neu anfangen

und genauso

Delphi-Quellcode:

variable:=1;
variable:=variable-1;
// Soll jetzt nicht 0 sein, sondern 3

Ich hoffe das war einigermaßen verständlich...
Gibts da was, wie man das realisieren kann oder muss man da mehr oder weniger viel Aufwand treiben? (Mit if-Anweisungen und so kann ich das sonst auch alleine... :-D )

[Bernhard Geyer]

Einfach einen neuen Typ definieren und diesen verwenden.

Delphi-Quellcode:

type
  TMyType = 1..3;

[dataspider]

Hi,

aus meiner Sicht durch ein Property relisierbar.

Delphi-Quellcode:

  privat
    FVariable: Integer;
    procedure SetVariable(const Value: Integer);
    { Private-Deklarationen }
  public
    property Variable: Integer read FVariable write SetVariable;
    { Public-Deklarationen }
  end;
  ...

implementation

procedure TForm1.SetVariable(const Value: Integer);
begin
  if FVariable <> Value then
  begin
    if Value in [1..3] then
      FVariable := Value
    else
      if Value > 3 then
        FVariable := 3
      else
        FVariable := 1;
  end;
end;

Cu, Frank

[ichbins]

ich glaube es ist doch einfacher, speicherschonender und vor allem schneller mit einem Variablentypen:

Delphi-Quellcode:

procedure bla;
var
  i:1..3;
begin
  bla;
  bla;
end;

die Variable kann wie eine Integer, Int64 oder Byte -Variable verwendet werden.

[nupset]

erstmal danke für die schnellen Reaktionen!!
Ich hätte vielleicht anmerken sollen, dass ich mich grad mal seit 2 Wochen mit Delphi beschäftige, demnach ist mir die Antwort von dataspider etwas zu hoch. sry.
Die beiden anderen Möglichkeiten hören sich ganz gut an, funzen aber irgendwie nicht. die Werte gehen ohne Rücksicht auf verluste über 3 hinaus. Oder mach ich da was falsch??

Delphi-Quellcode:

type TMyType = 1..3;
var test:TMyType;

begin
test:=1;
repeat
  showmessage(IntToStr(test));
  test:=test+1;
until false;
end;

und das andere

Delphi-Quellcode:

var test:1..3;

begin
test:=1;
repeat
  showmessage(IntToStr(test));
  test:=test+1;
until false;
end;

Oder bin ich einfach nur zu blöd?? (Antwort 'Ja' wird nicht akzeptiert :-D )

[marabu]

Herzlich Willkommen in der Delphi-PRAXiS.

Kommst du damit zurecht?

Delphi-Quellcode:

function Successor(const n, min, max: Integer): Integer;
begin
  if Succ(n) > max
    then Result := min
    else Result := Succ(n);
end;

function Predecessor(const n, min, max: Integer): Integer;
begin
  if Pred(n) < min
    then Result := max
    else Result := Pred(n);
end;

Grüße vom marabu

[nupset]

Warum einfach, wenns auch kompliziert geht..?
Dann deklarier ich ma lieber ne normale int-variable und mach das mit if-Anweisung. Ich brauch das nur einmal in meinem Programm. Also

Delphi-Quellcode:

test:=test+1;
if test=4 then test:=1;
if test=0 then test:=0;

hatte bloß gedacht, dass es vlt eine schnellere Methode gibt, da das in ner OnTimer-Prozedur ist und schnell von statten gehn muss...

Trotzdem danke allerseits!

[Hobby-Programmierer]

Zitat:

Zitat von nupset

Warum einfach, wenns auch kompliziert geht..?

Delphi-Quellcode:

test:=test+1;
if test=4 then test:=1;
if test=0 then test:=0;

:wiejetzt:
Ich dachte Deine Variable sollte nur Werte innerhalb 1..3 annehmen?

Mein Vorschlag aus dem Kopf und ungetestet:

Delphi-Quellcode:

var i: Cardinal;
begin
  if i in [1..3] then
    // Dein Code wenn i < 4
   else
    i:= Low(i); // oder i:= 1
end;

sonst:

Delphi-Quellcode:

var i: Cardinal
begin
  if i > 3 then
    i:= 0;
end;

Musst Dich nur entscheiden welche untere Grenze gilt und die Beispiele entsprechend anpassen!!
Gruss Mario :dancer:

[Hobby-Programmierer]

Upss :oops:
Hab zu spät gelesen das 0 = 3 ergeben soll, Sorry
Ungetestet und sicher noch verbesserungswürdig

Delphi-Quellcode:

var i: Integer;
begin
  Case i of
    0   : i:= 3;
    1..2: Inc(i);
    3   : i:= 1;
  end;
end;

Das Hochzählen von I erfolgt nur wenn I > 0 und I < 3, weils sonst Quatsch währe
Gruss Mario :dancer:

[nupset]

Ok, tut mir light. da hab ich mich wohl etwas falsch ausgedrückt. Die Variable soll nur Werte zwischen 1 und 3 annehmen, aber die einzige Operation dafür ist eben +1 und -1 also nimmt die Variable mit meiner lösung nur Werte von 1-3 an. ich dachte bloß, dass es vielleicht irgendeine Möglichkeit gibt, so eine Art 'kreisförmige' variable zu erstellen.

Delphi-Quellcode:

{
  2
/   \
1 -  3
}

(Musste das mal in Code-Tags packen, weil der sonst die Leerzeichen frisst und die schööööne 'Zeichnung' dadurch killt.. :evil: )
und dann quasi +1 -> im Uhreigersinn einen Wert weiter und
-1 -> entsprechend gegen den Uhrzeigersinn

Aber mit meiner lösung funzt das nu auch bei nem Timer Intervall von 1ms.

[Chewie]

Was ist denn jetzt mit

Delphi-Quellcode:

var
  i: 1..3;

Ganzzahlen in Pascal können als Aufzählungen von solchen Zahlen aufgefasst werden. Wenn ich mich nicht ganz täuschen sollte, sind die Datentypen in FreePascal wie folgt deklariert:

Delphi-Quellcode:

type
  Byte = 0..255;
  Word = 0..65535;
  //etc.

Sofern die Bereichsüberprüfung abgeschaltet ist, sollte 3 + 1 1 ergeben.

Hast du das jetzt schon mal ausprobiert?

[Christian Seehase]

Moin Zusammen,

@Chewie:
Das funktioniert leider nicht.
Ohne Range Checking wird einfach weitergezählt, und mit bekommt man eine Excpetion.

@nupset:
Auch wenn Dir das nicht weiterhelfen kann, möchte ich, der Vollständigkeit halber, noch eine Variante beitragen:

In D2006 kann man sich einen entsprechenden Typen mit Hilfe von operator overloading deklarieren:

Delphi-Quellcode:

interface

type
  TOneToThree = record
    var Value : integer;
    class operator Implicit(Value : TOneToThree) : integer;
    class operator Implicit(Value : integer)     : TOneToThree;
    class operator inc(Value : TOneToThree)      : TOneToThree;
    class operator dec(Value : TOneToThree)      : TOneToThree;
  end;

implementation

class operator TOneToThree.Implicit(Value: TOneToThree): integer;
begin
  Result := Value.Value;
end;

class operator TOneToThree.dec(Value: TOneToThree): TOneToThree;
begin
  case Value.Value of
    2,3 : Result.Value := Value.Value-1;
    else Result.Value := 3;
  end;
end;

class operator TOneToThree.Implicit(Value: integer): TOneToThree;
begin
  if Value > 3 then begin
    Result.Value := 1;
  end else begin
    if Value < 1 then begin
      Result.Value := 3;
    end else begin
      Result.Value := Value;
    end;
  end;
end;

class operator TOneToThree.inc(Value: TOneToThree): TOneToThree;
begin
  case Value.Value of
    1,2 : Result.Value := Value.Value+1;
    else Result.Value := 1;
  end;
end;

Deklariert man sich jetzt eine Variable vom Typ TOneToThree, so kann dieser ein beliebiger integer-Wert zugewiesen werden, der in den Bereich von 1 bis 3 gezwungen wird, ausserdem wird der Bereich bei Verwendung von inc/dec eingehalten.
Man kann das Ganze natürlich noch erweitern, so dass, z.B., auch + und - sich entsprechend verhalten.

[tigerman33]

Hi,

aber mal eine generelle Frage: Wozu bietet Delphi mir denn die Möglichkeit, subranges wie 1..3 zu deklarieren, wenn es sie dann anschließend geflissentlich ignoriert? Hat das irgendeinen tieferen Sinn, der dahinter steckt?
Hatte so eine Situation nämlich auch schon. Da stand dann ein eigentlich "ungültiger" Wert in einer Variable, der an einer gaaaaanz anderen Stelle im Projekt einen Fehler verursachte. Hat ewig gedauert bis ich das gefunden hatte. :stupid: Und mich außerdem ziemlich geärgert damals.

[marabu]

Hi Christian,

Teilbereichstypen erhöhen die Stabilität deines Codes, wenn du während der Testphase die Bereichsüberprüfung des Compilers einschaltest. Ohne die Bereichsüberprüfung werden nur Bereichsverletzungen durch Konstanten erkannt.

Grüße vom marabu