Integer in Set laden

[samso]

Zitat:

Zitat von DieDolly (Beitrag 1449812)

Aber da oben wird doch im Prinzip geprüft, ob die 1 in der 57 ist.

Und das stimmt eben nicht! Da wird geprüft ob nB in der Menge NiveauInt enthalten ist. Hier bildet Pascal/Delphi die Mengenlehre nach.

[p80286]

Zitat:

Zitat von Uwe Raabe (Beitrag 1449815)

Zitat:

Zitat von p80286 (Beitrag 1449814)

Warum machst Du es nicht nach alter Väter Sitte

Ich hatte schon auf so was gewartet...

Na dann erzähl mal.
Ich hab bisher den Eindruck, daß der Einsatz eines Sets nicht eben intuitiv ist.


Gruß
K-H

[Uwe Raabe]

Zitat:

Zitat von p80286 (Beitrag 1449820)

Ich hab bisher den Eindruck, daß der Einsatz eines Sets nicht eben intuitiv ist.

Ist er eigentlich schon - und besser lesbar auch. Wie jedes programmtechnische Konstrukt muss man es halt beherrschen. Das unterscheidet die Sets nicht von Pointern, Arrays, Records, Strings oder Klassen - von Generics, Threads und Anonymen Methoden ganz zu schweigen. Der ASM-Verweis hatte schon seine Berechtigung. Damit lässt sich all das auch nach alter Väter Sitte realisieren. Ist aber vielleicht nicht erstrebenswert.

[Michael II]

Hallo Dolly

gib nicht auf :-D.

Die Vorschläge sind ja alle mehr als brauchbar.

Hier noch ein paar Funktionen, welche nützlich sein könnten...

allefaelle zählt alle möglichen Fälle (0..63) auf
niv_in_n prüft, ob ein Niveau im "Fall" n enthalten ist

niv_str wandelt ein Element in einen String um
nivset_str wandelt eine Menge in einen String um

Delphi-Quellcode:

uses System.TypInfo;


type
TNiveau = (nA, nB, nC, nD, nE, nF);
TNiveauSet = set of TNiveau;

function getNiveauSet( n : byte ) : TNiveauSet;
begin
 (*
  alle fälle aufzählen:
  Result := [];
  if n and 1 = 1 then Result := Result + [nA];
  if n and 2 = 2 then Result := Result + [nB];
  if n and 4 = 4 then Result := Result + [nC];
  if n and 8 = 8 then Result := Result + [nD];
  if n and 16 = 16 then Result := Result + [nE];
  if n and 32 = 32 then Result := Result + [nF];
   *)
  // oder einfacher so:
  Result := TNiveauSet( n );
end;

function niv_str( niv : TNiveau ) : string;
begin
  Result := GetEnumName(typeinfo(TNiveau),ord(niv));
end;

function nivset_str( nivset : TNiveauSet ) : string;
var niv : TNiveau;
begin
  Result := '';
  for niv := nA to nF do
    if niv in nivset then
      Result := Result + niv_str( niv ) + ' ';
end;

function niv_in_n( niv : TNiveau; n : byte ) : boolean;
begin
  Result := niv in getNiveauSet( n );
end;

function fallnummer( n : byte ) : string;
var nivset : TNiveauSet;
begin
  nivset := getNiveauSet( n );
  Result := nivset_str( nivset );
end;

function allefaelle : string;
var
  i: Integer;
  hs : string;
begin
  hs := '';
  for i := 0 to 63 do
      hs := hs + i.ToString + ' ' + fallnummer( i ) + #13#10;
  Result := hs;
end;


procedure TForm1.Button1Click(Sender: TObject);
begin
  showmessage(allefaelle);
end;

[samso]

In dem Augenblick in dem die Zahl in ein Set übertragen wurde, muss man gedanklich die Welt der Zahlen verlassen und in die Welt der Mengenlehre eintauchen. Hier wird nicht mehr mit Zahlen hantiert, sondern mit Elementbeziehungen. Das hier behandelte Beispiel ist geradezu ein Musterbeispiel für eine Menge. Die Menge der freigeschalteten Niveaus. Wenn die einzelnen Niveaus (Elemente der Menge) dann auch noch sinnvolle Namen bekommen, bildet die Programmiersprache wunderbar anschaulich ab was der Programmierer eigentlich will. Das ist dann fast schon Umgangssprache und genau das macht die Sache dann auch so sexy.

Richtig ist, dass die Zuweisung

Code:

Niveaus := TNiveauSet(Byte(StrToInt('57')));

nicht der reinen Lehre entspricht, weil diese Zuweisung implementationsabhängig ist. Sauberer wäre diese Formulierung:

Delphi-Quellcode:

function IntegerToNiveauSet(NiveauInt: Integer): NiveauSet;
var
  N: TNiveau;
  z: Integer;
begin
  z := 1;
  Result := [];
  for N := Low(TNiveau) to High(TNiveau) do
  begin
    if z and NiveauInt<>0 then
      include(Result, N);
    z := z * 2;
  end;
end;

Die Zuweisung lautet dann

Delphi-Quellcode:

Niveaus := IntegerToNiveauSet(StrToInt('57'));

[Rollo62]

Man könnte sich alternativ auch einen NiveauSet typ anlegen, der z.B. ein Byte ist,
und dann per record helper entsprechende Zugriffsfunktionen anlegen, die das sprachlich auch sehr anschaulich macht (und eventuell noch mehr bequeme Funktionen dazunehmen).
Wenn es im Wesentlichen um die sprachliche Erkennbarkeit geht.

[TiGü]

Wäre es nicht viel sinnvoller, nochmal über die Grundlagen von Bitfeldern/Bitmasken zu sprechen?

Denn hier hakt es gerade im Verständnis von DieDolly.

[freimatz]

Zitat:

Zitat von samso (Beitrag 1449840)

In dem Augenblick in dem die Zahl in ein Set übertragen wurde, muss man gedanklich die Welt der Zahlen verlassen und in die Welt der Mengenlehre eintauchen. Hier wird nicht mehr mit Zahlen hantiert, sondern mit Elementbeziehungen. Das hier behandelte Beispiel ist geradezu ein Musterbeispiel für eine Menge. Die Menge der freigeschalteten Niveaus.

Ich erlaube mir da einen kleinen Einwand. Für ein Musterbeispiel einer Menge stehen die Elemente der Menge in keiner Beziehung. Hier jedoch scheinen die Elemente eine bestimmte Reihenfolge zu haben. Auch der Name "Niveau" suggeriert das.

Ansonsten :thumb:

[Michael II]

Ich würde das auch nie mit Mengen programmieren.
Da Dolly aber Mengen verwendet, könnte es sein, dass Dolly Mengen verwenden muss.

Da Dolly eine Zahl als Input erhält, nehme ich an, dass auch die Programmierin/der Programmierer des Inputs schlicht mit Bitmasken gearbeitet hat.

[Uwe Raabe]

Zitat:

Zitat von freimatz (Beitrag 1449848)

Für ein Musterbeispiel einer Menge stehen die Elemente der Menge in keiner Beziehung. Hier jedoch scheinen die Elemente eine bestimmte Reihenfolge zu haben. Auch der Name "Niveau" suggeriert das.

Allerdings deutet der Eingabewert 57 an, daß in diesem Fall nur die Niveaus 1, 4, 5 und 6 freigeschaltet sind. Insofern ist der Mengenansatz hier schon gerechtfertigt.