array of byte / array of integer

Fred Ferkel · Beiträge: 87

hi

ich benötige einen array der strings,zahlen etc. speichern soll byte war meine erste wahl bis mir einfiel das ich irgendwo mal gelesen hab das das schlecht für die performance ist und das man 32bit variablen nehmen sollte um dem prozessor einfacheres arbeiten zu ermöglichen sollte ich nun tatsächlich einen integer array benutzen?

mfg sven

Hopsekey · Beiträge: 26

integer ist die bessere wahl, da integer einen größeren speicherbereich hat als byte. ich weiß ja nicht wie groß deine zahlen werden, aber bei byte ist deutlich eher schluss. du kannst auch einen record nehmen. weißt du was das ist? du schreibst einfach

markieren

Delphi-Quelltext

1:
2:
3:
4:
5:
6:
7:

type liste=record of
                   name:string;
                   zahl:integer;
                   ...
                 end;

var liste1:liste;

und ansprechen tust du es z.B. mit liste1.name

Moderiert von Tino: Delphi-Tags hinzugefügt.

Fred Ferkel · Beiträge: 87

hehe, ne du ich hab da schon son büschen mehr plan ^^

es geht mir darum das der prozessor wohl in den 16bit modus zurückspringt und daher langsamer wird wenn er mit Byte variablen arbeiten muss

ich benötige eine variable die jede art von variable speichern kann(natürlich nur die grundvariablen string/char/integer/int64/extended/byte/boolean) dafür hab ich jetzt nen array of byte implementiert aber nun hab ich das eben wieder gelesen und frage mich ob ich mein programm so umstrukturieren sollte damit der prozessor eben klarkommt, aber wird es dadruch wirklich schneller oder wird durch die zusätzliche arbeit der gewinn augewogen?

thx

-> genau diese vraiante wie sie von dir vorgeschalgen wird hab ich verworfen weil ich dann zich variablen deklarieren würde von denen ich eigentlich nur eine einzige brauche...

Wolff68 · Beiträge: 302 Erhaltene Danke: 1 WinXP home D6 Prof

Also was da nun schneller ist, weis ich auch nicht. Integer wird vielleicht eine Idee schneller sein als Byte, dafür hast aber auch mehr Daten, die gelesen werden, und und....

Zum Thema Variable beliebigen Types fällt mir noch Variant ein.
Könnte so ziemlich das sein, was Du suchst.
Andere Möglichkeit wäre ein Array aus Pointern, die dann auf dynamisch erzeugte Variablen zeigen.

_________________
"Der Mensch ist nicht was er sich vorstellt oder wünscht zu sein, sondern das was andere in ihm sehen."

Fred Ferkel · Beiträge: 87

stimmt schond as mit dem variant nur eben sagt die Delphi hilfe:

Zitat:

Variants, as they are called, offer greater flexibility but consume more memory than regular variables, and operations on them are slower than on statically bound types....
Variants can hold values of any type except records, sets, static arrays, files, classes, class references, pointers, and Int64.

und da wär ich wieder bei meinem ursprünglichne problem

[/b]

AndyB · Beiträge: 1173 Erhaltene Danke: 14 RAD Studio XE2

Fred Ferkel hat folgendes geschrieben:

es geht mir darum das der prozessor wohl in den 16bit modus zurückspringt und daher langsamer wird wenn er mit Byte variablen arbeiten muss

So ein Unsinn.
Heutige PCs haben eine 32Bit Datenleitung und können somit vom Arbeitsspeicher nur in Blöcken von 4 Bytes lesen. Wenn du also 4 Bytes einzeln einliest, dann wird 4x auf den Speicher zugegriffen (ist ja logisch). Wenn du nun auf 4 Integer zugreifst, wird ebenfalls 4x auf den Speicher zugegriffen. Im Endeffekt ergibt das keinen Unterschied, womit auch kein Performance-Verlusst auftritt.
Wenn dein Array jedoch nicht an einer 4 Byte Grenze liegt, so spürst du bei Bytes keinen unterschied zu einem Ausgerichteten-Array. Bei Integer ist es jedoch fatal, denn dann muss für das Lesen eines Integer 2x auf den Speicher zugegriffen werden. Da Delphi Variablen automatisch ausrichtet, sollte dies nicht vorkommen.

_________________
Ist Zeit wirklich Geld?

Fred Ferkel · Beiträge: 87

was sind ausgerichtete variablen/arrays?

was ich mit einem array of integer machen würde ist das ich statt z.B: den string 'String' in einen array of byte mit 6 variablen zu speichern in einen integer array aus 2 variablen speichern würde...

Ehemaliges Mitglied Erhaltene Danke: 1

@AndyB: Hier wird aber was anderes behauptet: www.optimalcode.com/integer.htm

AndyB · Beiträge: 1173 Erhaltene Danke: 14 RAD Studio XE2

Hast du auch diesen Teilsatz gelesen?

Zitat:

8 bit variables (Byte, SmallInt, Char) are not as bad

Von der Datenmenge hergesehen sind natürlich 32Bit Datentypen besser, da sie in der gleichen Zeit wie ein 8Bit Datentyp eingelesen werden können.

_________________
Ist Zeit wirklich Geld?

Fred Ferkel · Beiträge: 87

Hast du auch diesen Teilsatz gelesen?

Zitat:

if you do not mix their usage with 32 bit values. However, they can still cause the inclusion of additional instructions in order to zero out the rest of the 32 bit register.

lol

nimms mir nicht übel

na jedenfalls is mir der 2. satz nicht klar und mischen tut man die doch eh mehr oder weniger...?

Hopsekey · Beiträge: 26

hallo, hört doch auf euch zustreiten. du hast doch bestimmt schon mal was von strtoint, ... gehört. das geht so ziemlich mitallen und dann musst du dir nicht speichern was welche variable ist.

Fred Ferkel · Beiträge: 87

1. ich striete mich doch hier nun wirkich nicht das war doch nicht bös gemeint
2. ich wills nur eben nicht irgendwie hinbekommen, sondern auch in so gutem stil wie mir eben möglich

Wolff68 · Beiträge: 302 Erhaltene Danke: 1 WinXP home D6 Prof

Mal eine ganz andere Frage:

Wie behandelst Du das ein- und auslesen Deines ultra-schnellen Arrays?
Wie zB wandelst Du einen String, der aus Array-Integern besteht wieder in Zeichen? Wie merkst Du Dir was wo gespeichert ist und und und.

Genau DAS macht z.B. den Typen VARIANT Speicher- und Performance-Intensiver. (Gut, ich hab ihn nicht programmiert, vielleicht gibt es auch noch andere Gründe)

Wenn Du genau wissen willst, was nun schneller ist, dann mach eben mal eine Zeit-Messung mit verschiedenen Lösungen. Dann wirst zum einen Feststellen, was am schnellsten ist, und zum anderen, ob sich der Aufwand gegenüber einfacheren Methoden wirklich lohnt.

_________________
"Der Mensch ist nicht was er sich vorstellt oder wünscht zu sein, sondern das was andere in ihm sehen."

Fred Ferkel · Beiträge: 87

ist verwirrend und ohne richtige kommentare aber wenn du schon fragts...

das 1. byte speichert den typ alöso eine der constanten unten

geschwindigkeitstest ist gut..ma schaun
variant ist ja eben wegen int64 nichts und ich werd garantiert nur eine art und weise implementieren

markieren

Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:

const string_notv=0;
const char_notv=1;
const integer_notv=2;
const int64_notv=3;
const byte_notv=4;
const extended_notv=5;
const boolean_notv=6;

const string_v=7;
const char_v=8;
const integer_v=9;
const int64_v=10;
const byte_v=11;
const extended_v=12;
const boolean_v=13;

type
  TDataSetArray = array of array of array of array of Byte;
type
  PTDataSetArray = ^TDataSetArray;

------------------

          case PTDSA^[Index.LineIndex][Index.SubLineIndex][l3][0] of
             string_v:
                 begin
                   Move(PTDSA^[Index.LineIndex][Index.SubLineIndex][l3][1],ReMergeVar_string,High(PTDSA^[Index.LineIndex][Index.SubLineIndex]));
                   TableEdits[l2][l3].Text:=ReMergeVar_string;
                 end;
             char_v:
                 begin
                   Move(PTDSA^[Index.LineIndex][Index.SubLineIndex][l3][1],ReMergeVar_char,High(PTDSA^[Index.LineIndex][Index.SubLineIndex]));
                   TableEdits[l2][l3].Text:=ReMergeVar_char;
                 end;
             integer_v:
                 begin
                   Move(PTDSA^[Index.LineIndex][Index.SubLineIndex][l3][1],ReMergeVar_integer,High(PTDSA^[Index.LineIndex][Index.SubLineIndex]));
                   TableEdits[l2][l3].Text:=IntToStr(ReMergeVar_integer);
                 end;
             int64_v:
                 begin
                   Move(PTDSA^[Index.LineIndex][Index.SubLineIndex][l3][1],ReMergeVar_int64,High(PTDSA^[Index.LineIndex][Index.SubLineIndex]));
                   TableEdits[l2][l3].Text:=IntToStr(ReMergeVar_int64);
                 end;
             byte_v:
                 begin
                   Move(PTDSA^[Index.LineIndex][Index.SubLineIndex][l3][1],ReMergeVar_byte,High(PTDSA^[Index.LineIndex][Index.SubLineIndex]));
                   TableEdits[l2][l3].Text:=IntToStr(ReMergeVar_byte);
                 end;
             extended_v:
                 begin
                   Move(PTDSA^[Index.LineIndex][Index.SubLineIndex][l3][1],ReMergeVar_extended,High(PTDSA^[Index.LineIndex][Index.SubLineIndex]));
                   TableEdits[l2][l3].Text:=FloatToStr(ReMergeVar_extended);
                 end;
             boolean_v:
                 begin
                   Move(PTDSA^[Index.LineIndex][Index.SubLineIndex][l3][1],ReMergeVar_boolean,High(PTDSA^[Index.LineIndex][Index.SubLineIndex]));
                   TableEdits[l2][l3].Text:=GetBooleanString(ReMergeVar_boolean);
                 end;
          end;

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme