Menge von Integerzahlen schnell u. einfach merken?

[PeterPanino]

Welche Methode würdet ihr verwenden, um möglichst schnell und einfach eine Menge von Integerzahlen (deren Anzahl zur Laufzeit noch nicht bekannt ist) in einer definierten Reihenfolge zu speichern (d.h. zu merken)? Die Betonung liegt auf schnell und einfach - würdet ihr gleich ein dynamisches Array verwalten oder gibt es eine einfachere Methode?

[Hansa]

Es gibt da genug. Z.B.: TList. Wenn es schnell sein soll, aber nicht einfach, dann nehme verkettete Listen.

[PeterPanino]

Zitat:

Zitat von Hansa

TList.

Ich möchte dafür keine eigene Klasse schreiben. Meinst du die Methode, mit der statt der Objektzeiger die Integerwerte gespeichert werden?

[Hansa]

Je ne pas compris. :mrgreen: Du willst keine Klase neu schreiben ? Wo liegt denn das Hindernis ? Das macht doch Delphi sowieso alles. Wieso neu schreiben ? :shock:

[PeterPanino]

Zitat:

Zitat von Hansa

Je ne pas compris. :mrgreen: Du willst keine Klase neu schreiben ? Wo liegt denn das Hindernis ? Das macht doch Delphi sowieso alles. Wieso neu schreiben ? :shock:

Ich meine eine Klasse, in der weitere Verwaltungsfunktionen enthalten sind.

[Hansa]

Ja, welche denn ? Nimm eben TObjectList. Da ist Add, Sort, Last und was weiß ich noch drin.

[sx2008]

Zitat:

Zitat von PeterPanino

Ich möchte dafür keine eigene Klasse schreiben.

Du kannst dich nicht duschen ohne nass zu machen!
Und von Nix kommt Nix !

Variante A:
Man kann die Daten in einem dynamischen Array speichern.
Also z.B. Array mit 32 Elementen anlegen und eine Variable CurrentIndex führen.
Wenn CurrentIndex = 32 dann wird die Grösse der Arrays mit SetLength() verdoppelt.
Dabei müssen alle Elemente vom alten Speicherplatz auf den neuen Speicherplatz kopiert werden.
Dabei muss die ganze Logik im Anwendungsprogramm untergebracht werden.
Es ist also nicht schnell und einfach.
Auch ist es nicht wiederverwendbar oder sicher.

Variante B:
Andererseits kann man die Klasse TList ableiten und dann verwenden.
Um die neue KLasse TIntList schreiben zu können muss man verstehen wie TList funktioniert.
Die Anwendung der Klasse ist dagegen recht simpel und schnell.
Nachteil: pro Element werden 4 zusätzliche Bytes für einen Zeiger notwendig.
Man braucht also doppelt so viel Speicher wie beim dynamischen Array.

Variante C:
Man arbeitet mit mehreren dynmischen Arrays. Wenn ein Array voll ist, wie ein weiteres
dynamisches Array angelegt.
Dies vermeidet die Nachteile von Variante A (kopieren grosser Speicherblöcke, Speicherfragmentierung)
und den Nachteil von Variante B (doppelter Speicherplatz).
Allerdings ist die Verwaltung von mehreren Arrays nur durch eine Klasse möglich.
Die einzelnen Arrays werden sozusagen virtuell zu einem grossen Array zusammengesetzt.
Technisch ist das die beste Lösung.

[Hansa]

Wegen 4 Bytes macht nur B einen Sinn. Leute, wir leben im Zeitalter von Gigabytes !! Wegen Delphi braucht man auch nicht noch unnötig im Source Klimmzüge zu machen.

[Luckie]

Zitat:

Zitat von Hansa

Wegen 4 Bytes macht nur B einen Sinn. Leute, wir leben im Zeitalter von Gigabytes !! Wegen Delphi braucht man auch nicht noch unnötig im Source Klimmzüge zu machen.

Sich aber dann beschweren, wen Vista und Firefox einem den RAM auffressen.... :?

[SirThornberry]

ich persönlich würde ein Array nehmen. Allerdings ist genau so gut auch eine TList. Nichts mit ableiten etc. Die TList verwaltet Pointer welche 32 bit groß sind. Integer sind ebenfalls 32bit groß. Entsprechend kann man durch einen einfachen Cast auch Integer darin speichern. Denn letztendlich ist es eine Interpretationssache ob man das was im Speicher steht als Integer, Pointer, String etc. ansieht.

[Horst_]

Hallo,

wenn der Wertebereich der Intgervariablen bekannt und klein ist (Bleibt dem Anwender überlassen ob 1000 oder 100 mio klein ist) legt man nur ein Feld für den Wertebereich an und zählt das jeweiige vorkommen. Dann sind die Daten sogar sortiert.

Gruß Horst

[BloodySmartie]

Das erinnert mich an das Buch "Perlen der Programmierkunst".

Problematik: Sortiere eine Menge an 8-stelligen Telefonnummern, entferne doppelte Zahlen und das bitte in minimaler Zeit und mit minimalem Speicherverbrauch.

Lösung: ein Bit-Array, dessen Index die Tel-Nr. darstellt und dessen Wert einfach nur anzeigt, ob sie in der Menge vorhanden ist oder nicht. Ums Sortieren und um Dubletten muss man sich gar nicht kümmern.

[Tyrael Y.]

Zitat:

Zitat von SirThornberry

ich persönlich würde ein Array nehmen. Allerdings ist genau so gut auch eine TList. Nichts mit ableiten etc. Die TList verwaltet Pointer welche 32 bit groß sind. Integer sind ebenfalls 32bit groß. Entsprechend kann man durch einen einfachen Cast auch Integer darin speichern. Denn letztendlich ist es eine Interpretationssache ob man das was im Speicher steht als Integer, Pointer, String etc. ansieht.

So ist es...wenn du zu faul bist das Casten in Integer selbst zu übernehmen, dann google mal nach TIntegerList....ist eine gaaaanz einfache und auch selbst schnell getippte Ableitung von TList.


Edit:
Hier für faule...es kann natürlich noch erweitert werden.

Delphi-Quellcode:

unit IntegerList;

interface

uses
  Classes;

type
  TIntegerListSortCompare = function (Item1, Item2: Pointer): Integer;
  TIntegerList = class(TList)
  private
    function Get(Index: Integer): Integer; reintroduce;
    procedure Put(Index: Integer; const Value: Integer); reintroduce;
  public
    function Add(Item: Integer): Integer; reintroduce;
    function Extract(Item: Integer): Integer; reintroduce;
    function IndexOf(Item: Integer): Integer; reintroduce;
    procedure Insert(Index: Integer; Item: Integer); reintroduce;
    function Last: Integer; reintroduce;
    function Remove(Item: Integer): Integer; reintroduce;
    procedure Sort(Compare: TIntegerListSortCompare); reintroduce;
    property Items[Index: Integer]: Integer read Get write Put; default;
  end;

implementation

{ TIntegerList }

function TIntegerList.Add(Item: Integer): Integer;
begin
  Result := inherited Add(Pointer(Item));
end;

function TIntegerList.Extract(Item: Integer): Integer;
begin
  Result := Integer(inherited Extract(Pointer(Item)));
end;

function TIntegerList.Get(Index: Integer): Integer;
begin
  Result := Integer(inherited Items[Index]);
end;

function TIntegerList.IndexOf(Item: Integer): Integer;
begin
  result := inherited IndexOf(Pointer(Item));
end;

procedure TIntegerList.Insert(Index, Item: Integer);
begin
  inherited Insert(Index, Pointer(Item));
end;

function TIntegerList.Last: Integer;
begin
  Result := Integer(inherited Last);
end;

procedure TIntegerList.Put(Index: Integer; const Value: Integer);
begin
  inherited Items[Index] := Pointer(Value);
end;

function TIntegerList.Remove(Item: Integer): Integer;
begin
  Result := inherited Remove(Pointer(Item));
end;

procedure TIntegerList.Sort(Compare: TIntegerListSortCompare);
begin
  inherited Sort(TListSortCompare(Compare));
end;

end.

[PeterPanino]

Zitat:

Zitat von Tyrael Y.

So ist es...wenn du zu faul bist das Casten in Integer selbst zu übernehmen, dann google mal nach TIntegerList....ist eine gaaaanz einfache und auch selbst schnell getippte Ableitung von TList.[/delphi]

Kommt darauf an, wofür man die Liste braucht. Die Ausgangsanforderung war ja: Schnell und einfach mal ein paar Integers merken.

Trotzdem vielen Dank an alle für die nützlichen Beiträge!

[Tyrael Y.]

Zitat:

Zitat von PeterPanino

Kommt darauf an, wofür man die Liste braucht. Die Ausgangsanforderung war ja: Schnell und einfach mal ein paar Integers merken.

Trotzdem vielen Dank an alle für die nützlichen Beiträge!

120% der Anforderungen erfüllt würde ich sagen :D

es ist schnell, einfach und zudem lassen sich die Integer gut verwalten. ;)