Variablenwert Bestandteil einer Menge ? wie Zeitkritisch ???

[richard_boderich]

hallo leute!

ich hab mal wieder ein problem also:

ich hab verschiedene Mengen, die asciicodes von zeichen als dezimalwerte enthalten.

z. B.

Delphi-Quellcode:

test = set of byte;

test:=96,97,98 steht für  a,b,c laut ascii tabelle

teste jetz in einer for next schleife mit einer if abfrage , ob ein variablenwert x, in der menge enthalten ist

was ist nun aber , wenn die mengen größer werden, sagen wir mal 255 werte? wuerde das die ausführungszeit
meiner for next schleife nachhaltig beeinflussen (wenn das ganze ne sekunde dauert, kann ich das vergessen,da
ich die for next zur bildschirmausgabe nutze, und eine stringgrid mit daten fuettere)

PS: waehre nett, wenn mir jemand mal, die codepages für intels little und big-endian, macintosh, Ebcdic und asci 7 bit
zukommen lassen koennte

danke schon mal im vorraus :)

[Robert Marquardt]

Sets duerfen nur 256 Elemente haben und der Test ist einfach eine Bitverknuepfung, also sehr effizient.

[richard_boderich]

Danke Robert,

hab es einfach mal probiert, und es läuft super. eine frage haett ich noch

ich hab jetz meine menge folgendermaßen deklariert:

Delphi-Quellcode:

var 
    charset1,charset2,charset3 : set of byte;
    i:integer;
...

begin
    i:=1;   // aktuelles charset setzen
    charset1 := [46..255];
    charset2 := [46..200];
    charset3 := [21..255];

ich will aber das entsprechende set dynamisch auswaehlen koennen.

geht das so ???

Delphi-Quellcode:

if x in charset[i] then bla,blab,bla...

ich bekomme immer ne meldung inkompatible typen,damit weis ich nix anzufangen

[Sharky]

Hai Richard,

ungetestet:

Delphi-Quellcode:

var 
    aktcharset : set of byte;
    charset1,charset2,charset3 : set of byte;
    i:integer;
...

begin
  i:=1;   // aktuelles charset setzen
  charset1 := [46..255];
  charset2 := [46..200];
  charset3 := [21..255];
  case i of
    1 : aktcharset := charset1;
    2 : aktcharset := charset2;
    3 : aktcharset := charset3;
  end;
 if x in aktcharset then bla,blab,bla...

[choose]

Hallo richard_boderich,

wenn ich Dich richtig verstehe, ist Deine Variable x ein Char und Deine Sets Mengen vom Typ Byte. Wusstest Du, dass Du Sets auch vom Typ Char anlegen kannst um Konstrukte der Art

Delphi-Quellcode:

var
  myChar: Char;
  myLetters: Set of Char;
  myDigitsAndOperators: Set of Char;
begin
  myChar := ObtainAChar;
  myLetters := ['A'..'Z'];
  myDigitsAndOperators := ['0'..'9', '+', '-', '/', '*'];

  if myChar in myLetters then 
    DoSth(myChar)
  else
    if myChar in myDigitsAndOperators then
      DoSthElse(myChar, ASecondParameter)
    else
      DoDefaultBehavior;
end;

zu realisieren?

Solche Sets können selbstverständlich auch zur Laufzeit berechnet werden (siehe auch OH zu Include, Exclude), zB so

Delphi-Quellcode:

type
  TCharSet = set of Char;

function AdditionalChars: TCharSet;
begin
  Result := [ObtainAChar];
end;
//...
begin
  myLetters := ['A'..'Z'] + AdditionalChars;

Wenn die Sets hingegen, wie in meinem ersten Beispiel, fest sind, könntest Du auch eine einfache Case-Anweisung verwenden:

Delphi-Quellcode:

case myChar of
  'A'..'Z': DoSth(myChar);
  '0'..'9', '+', '-', '/', '*': DoSthElse(myChar, ASecondParameter);
else
  DoDefaultBehavior;
end;

[Chewie]

Oder gleich so:

Delphi-Quellcode:

var
    charset : Array of set of byte;
    i:integer;
begin
    i:=0;   // aktuelles charset setzen
    charset[0] := [46..255];
    charset[1] := [46..200];
    charset[2] := [21..255];
    if x in charset[i] then bla,blab,bla...

[richard_boderich]

@choose ,

ne ,das haste wat falsch verstanden, x ist eine dezimaler bytewert z.b. 245.
ich muss testen ob dieser wert in der aktuellen menge vorkommt

ich weis das ich auch solche charsets anlegen kann 'a','b', 'c' usw.
aber definiere da mal die ganzen sonderzeichen, da wird es dann schon eng
(schau dir mal die ascii tabelle an)

deswegen nehm ich die bytewerte und wandel sie zu laufzeit in chars

das, das berechnen von sets zur laufzeit moeglich ist , wusst ich noch nich, wirklich faszinierend :stupid: , danke hab wiederwas dazugelernt :idea:

aber trotzdem many thank's

@chewie,

deine loesung sieht supi aus,kurz und geradlinieg, scheinen aehnlich zu denken, meine code war fast genauso werd ich ma testen :)

thanks


meine loesung war:

Delphi-Quellcode:

   charset1,charset2,charset3 :  set of byte; 
   i:integer; 
begin 
    i:=0;   // aktuelles charset setzen 
    charset[0] := [46..255]; 
    charset[1] := [46..200]; 
    charset[2] := [21..255]; 
    if x in charset[i] then bla,blab,bla...

hatt aber nicht funktioniert, weis jemand wieso charset hab ich doch als dynamische oder indexvariable angesrochen?
will aber verstehen wo mein fehler war, denke mal das deplhi indexvariablen anders kennzeichnet im syntax oder ?

[richard_boderich]

@chewie,

deine loesung funzt nich, bekomme eine exeption

bei der zuweisung der setwerte

Delphi-Quellcode:

var 

charset: array of set of byte;

...

begin

 charset[0] := [46..255];  <- exeption
 charset[1] := [46..200];
 charset[2] := [21..255];

[choose]

Zitat:

Zitat von richard_boderich

ich weis das ich auch solche charsets anlegen kann 'a','b', 'c' usw.
aber definiere da mal die ganzen sonderzeichen, da wird es dann schon eng
(schau dir mal die ascii tabelle an)

deswegen nehm ich die bytewerte und wandel sie zu laufzeit in chars

Solche Sets kannst Du wie folgt anlegen:

Delphi-Quellcode:

myLetters := [#65..#67, 'D'..'E']; // eq ['A'..'E'];

und ersparst damit den Cast von Char zu Byte und umgekehrt. Insgesamt also wesentlich übersichtlicher und ggf sicherer durch die Typenstrenge...

EDIT: Selbiges gilt selbstverständlich auch für die Lösung via Case

[richard_boderich]

@chewie,

deine loesung funzt nich, bekomme eine exeption

bei der zuweisung der setwerte

Delphi-Quellcode:

var 

charset: array of set of byte;

...

begin

 charset[0] := [46..255];  <- exeption
 charset[1] := [46..200];
 charset[2] := [21..255];

[Sharky]

Hai Richard,

so ist es ja auch ein dynamisches Array dessen größe erst definiert werden muss.

[choose]

Zitat:

Zitat von richard_boderich

@chewie,

deine loesung funzt nich [..]

Delphi-Quellcode:

var 
charset: array of set of byte;

Dynamische Arrays sind in der Handhabung etwas umständlicher, weil sie vor einem Zugriff zunächst initialisert (OH: SetLength) werden müssen.

Wenn ich Deine Anmerkung richtig deute, arbeitest Du mit vollstäding festen Werten, richard_boderich. Nutze in diesem Fall am besten konstante Arrays der Form

Delphi-Quellcode:

type
  TCharSet = set of Char;
const 
  Letters = ['A'..'Z'];
  Digits = ['0'..'9'];
  arSets: array[0..2] of TCharSet = 
    (Letters, Digits, [#0..#255]-Letters-Digits);
begin
  Result := AChar in arSets[AChoice];

noch eleganter bekommst Du das dann hin, indem Du einen Typen

Delphi-Quellcode:

type
  TChoice = (cLetters, cDigits, cMisc);

definierst und das array wie folgt deklarierst

Delphi-Quellcode:

const
  arSets: array[TChoice] of TCharSet

[Sharky]

Zitat:

Zitat von Sharky

Hai Richard,

so ist es ja auch ein dynamisches Array dessen größe erst definiert werden muss.

Nachtrag:

Delphi-Quellcode:

type
  tset = set of byte;

var
  charset: array[0..2] of tset;  // Statiches Array
  dyncharset : array of tset;    // Dynamisches Array

procedure TForm1.Button1Click(Sender: TObject);  // Hier wird das stat. Array gesetzt.
begin
  charset[0] := [46..255];
  charset[1] := [46..200];
  charset[2] := [21..255];
end;

procedure TForm1.Button2Click(Sender: TObject);  // und hier das Dyn. Array
begin
  SetLength(dyncharset,SizeOf(tset)*3);
  dyncharset[0] := [46..255];
  dyncharset[1] := [46..200];
  dyncharset[2] := [21..255];
end;

[richard_boderich]

jungens, hilfe, nicht alles auf einmal, das ist zuviel fuer mich

also ich komme ueberhaupt nich mehr mit, deswegen erklare ich jetz nochmal was ich machen, will.
ich glaube ihr versteht mich falsch, das ganze ist eigentlich sehr einfach

also, ich hab ein array of byte, dort stehen dezimale bytewerte drin,
diese stelle ich in der procedure ausgabe in einem stringrid dar mit ner for next und stringgrid.cells [x,y]:=char("arraywert");

Delphi-Quellcode:

if x in charset[i] then stringgrid.cells [x,y]:=char("arraywert");

da ich aber verschiedene formate bei der darstellung will, z.b Bigendien, ascii 7-bit oder macintosh
muss ich verschieden charsets haben, diese brauchen nur einmal definiert werden und sollen nicht geaendert werden

z.b in formcreate:

Delphi-Quellcode:

var
charset1,charset2,charset3: set of byte;

...

begin
charset1:=[46..255]; //sets initialisieren
charset2:=[21..200];
charset3:=[0..12];

jetz hab ich ein menu mit verschiedenen menupunkten

die routinen sehen so aus

Delphi-Quellcode:

tform1.menupunkt1.click
begin
   
   i:=0;   // charset 0 setzen
   ausgabe // stringgrid mit geaenderten zeichsatz fuellen

end;

tform1.menupunkt2.click
begin
   
   i:=1;   // charset 1 setzen
   ausgabe // stringgrid mit geaenderten zeichsatz fuellen

end;

will also nur das ensprechen charsetz auswaehlen, und rufe dann die procedure ausgabe nochmal auf um den gridinhalt zu aktualisieren

[Sharky]

Hai richard,

wir haben dich schon verstanden ;-)

Du möchtest es also so haben:

Delphi-Quellcode:

implementation

{$R *.dfm}

type
  tset = set of byte;

var
  i : Integer;
  x : Byte;
  charset: array[1..3] of tset;  // Statiches Array

procedure TForm1.FormCreate(Sender: TObject);
begin
  i := 1;  // CharSet 1 ist Standard
  charset[1] := [46..255];  // Initialisierung der 
  charset[2] := [46..200];  // CharSets
  charset[3] := [21..255];
end;

procedure Anzeige;
begin
 //  Zum füllen deiner StringGrids
  if x  in charset[i] then
  begin
  end;
end;

procedure TForm1.CharSet12Click(Sender: TObject);  // CharSet 1
begin
  i := 1;
  Anzeige;
end;

procedure TForm1.CharSet21Click(Sender: TObject);  // CharSet 2
begin
  i := 2;
  Anzeige;
end;

procedure TForm1.CharSet31Click(Sender: TObject);  // CharSet 3
begin
  i := 3;
  Anzeige;
end;

[richard_boderich]

@sharky,

ja genauso will ich es haben, und geauso hab ichs doch gemacht, und cheewie auch,
das einzige neue was ich entdecken kann , ist die typeanweisung ganz oben :gruebel:

[Sharky]

Zitat:

Zitat von richard_boderich

.. und geauso hab ichs doch gemacht, ...

Ach so, ich dachte dir wäre noch etwas unklar :stupid;

Zitat:

das einzige neue was ich entdecken kann , ist die typeanweisung ganz oben

Die habe ich nur aus gewohnheit benutzt. Du kannst es auch so schreiben:

Delphi-Quellcode:

var
  charset1 : Array [1..2] of Set of Byte

macht ersteinmal noch keinen Unterschied.

[richard_boderich]

@ sharky,

hab es jetz geloest,borge mir mal deine code

Delphi-Quellcode:

implementation 

{$R *.dfm} 


var 
  i : Integer; 
  x : Byte; 
  charset: array[1..3] of set of byte;  // Statiches Array 

procedure TForm1.FormCreate(Sender: TObject); 
begin 
  i := 1;  // CharSet 1 ist Standard 
  charset[1] := [46..255];  // Initialisierung der 
  charset[2] := [46..200];  // CharSets 
  charset[3] := [21..255]; 
end; 

procedure Anzeige; 
begin 
//  Zum füllen deiner StringGrids 
  if x  in charset[i] then 
  begin 
  end; 
end; 

procedure TForm1.CharSet12Click(Sender: TObject);  // CharSet 1 
begin 
  i := 1; 
  Anzeige; 
end; 

procedure TForm1.CharSet21Click(Sender: TObject);  // CharSet 2 
begin 
  i := 2; 
  Anzeige; 
end; 

procedure TForm1.CharSet31Click(Sender: TObject);  // CharSet 3 
begin 
  i := 3; 
  Anzeige; 
end;

wenn ich es richtig sehe , war mein einziger fehler, das ich bei der charset arraydefinition, keinen festgelegten bereich angegeben hab,
dadurch nahm delphi an, es sei ein dyn. array, und da ich das nicht wollte, und damit natuerlich nicht mit setlenght definiert habe, die
exeption, ist das so richtig ???

[Sharky]

Hai Richard,

jetzt verwirre ich dich total :stupid:
Schaue mal was ich jetzt gemacht habe:

Delphi-Quellcode:

type
  tCharset = set of byte;

procedure Anzeige (aktcharset : tCharset);  // Das SET of BYTE wird als Parameter übergeben.
var
  x : Byte;
begin
  //  Zum füllen deiner StringGrids
  if x  in aktcharset then
  begin
  end;
end;

procedure TForm1.CharSet12Click(Sender: TObject);  // CharSet 1
begin
  Anzeige([46..255]);
end;

procedure TForm1.CharSet21Click(Sender: TObject);  // CharSet 2
begin
  Anzeige([46..200]);
end;

procedure TForm1.CharSet31Click(Sender: TObject);  // CharSet 3
begin
  Anzeige([21..255]);
end;

Nicht falsch verstehen. Ich möchte Dir nur zeigen wie Du ganz schnell deinen Code für diesen Fall vereinfachen kannst.

[richard_boderich]

@sharky

uuuuuhhh,ooooohh, ahh wie jetz,

Neinnnnn, ich bin ein star, holt mich hier raus :-D :zwinker:

jo danke, aber einfach is immer relativ, habe bissher wenig mit typen und records gearbeitet, wer mich da mal einarbeiten.
war denn meine fehleranalyse richtig, s. vorheriges post ?

aber deine version sieht echt schon sehr elegant aus :)

thanks for your help

Richard

[Sharky]

Zitat:

Zitat von richard_boderich

...war mein einziger fehler, das ich bei der charset arraydefinition, keinen festgelegten bereich angegeben hab,
dadurch nahm delphi an, es sei ein dyn. array, und da ich das nicht wollte, und damit natuerlich nicht mit setlenght definiert habe, die
exeption, ist das so richtig ???

:thuimb: Genau das war das hüpfende Komma in deinem ersten Code.
.
.
.
.

Und weil ich heute so lustig bin:
Weise allen drei Menüpunkten die selbe OnClick procedure zu. Dann setzt Du bei Menüpunkt-1 die Eigenschaft Tag auf 1 beim zweiten auf 2 und beim dritten auf 3.
Dann kommt das dabei raus ;-)

Delphi-Quellcode:

type
  tCharset = set of byte;

procedure Anzeige (aktcharset : tCharset);
var
  x : Byte;
begin
  //  Zum füllen deiner StringGrids
  if x  in aktcharset then
  begin
  end;
end;

procedure TForm1.CharSet12Click(Sender: TObject);  // CharSet 1
begin
  Case (Sender As TMenuItem).Tag of
   1 : Anzeige([46..255]);
   2 : Anzeige([46..200]);
   3 : Anzeige([21..255]);
  end;
end;

[richard_boderich]

@sharky,

ich schließe mal den thread, du machst mir angst!!! :mrgreen: