Stringliste Umkehren

[waterboy]

Zitat von Klaus01:

.. ist denn TStringList.exchange nicht ehr für soetwas gut?

Delphi-Quellcode:

j:=0;
for i:=daten.count -1 downto (daten.count -1) div 2 do
  begin
    daten.exchange(i,j);
    inc(j);
  end;

[ungetestet)

Aus der Hilfe zu Exchange:
Swaps the position of two strings in the list.

procedure Exchange(Index1, Index2: Integer); override;

Description

Call Exchange to rearrange the strings in the list. The strings are specified by their index values in the Index1 and Index2 parameters. Indexes are zero-based, so the first string in the list has an index value of 0, the second has an index value of 1, and so on.

If either string has an associated object, Exchange changes the index of the object as well.

Warning: Do not call Exchange on a sorted list except to swap two identical strings with different associated objects. Exchange does not check whether the list is sorted, and can destroy the sort order of a sorted list.

Grüße
Klaus

Super, klasse. Funktioniert einwandfrei. Vielen Dank, Klaus.
Warum es keine direkt Funktion in Delphi gibt (wie in Python z.B.) verstehe ich nicht...

viele Grüße

rainer

[freimatz]

Zitat von waterboy:

Warum es keine direkt Funktion in Delphi gibt (wie in Python z.B.) verstehe ich nicht...

Ich schon. Vermutlich weil es nur Dinge gibt die man auch braucht.

Natürlich wird das Umkehren einer Liste schon benötigt. Aber meistens sind es dann nicht einfache Listen sondern gleiche komplexere Datensätze die man in einem Grid hat und dann oft auch nach allen Spalten sortieren lassen kann.

Wofür brauchst Du denn das?

[bluesbear]

Zitat von Klaus01:

TStringList.exchange

Ich bin beschämt. Da kam ich nicht drauf <seufz>

[simon790]

Hallo Klaus
Deine Lösung funktioniert soweit ganz gut und schnell. Und sieht auch gut aus

Allerbesten Dank (auch an die anderen!)
Simon

[Hansa]

Ist das mit dem Downto nicht selbsterklärend ?

Delphi-Quellcode:

unit Test;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, Gauges;

type
  TForm1 = class(TForm)
    memo1: TMemo;
    memo2: TMemo;
    btn1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure btn1Click(Sender: TObject);
  private
    { Private-Deklarationen }
    sl : TStringlist;
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

uses DateUtils;

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
var i : Integer;
begin
  sl := TStringlist.Create;
  for i := 0 to 10 do
    sl.Add(IntToStr(i));
  memo1.Lines := sl;    // Stringlist-Inhalt an Memo übergeben
end;

procedure TForm1.btn1Click(Sender: TObject);
var i : Integer;
begin
  memo2.Lines.Clear;
  for i := sl.Count - 1 downto 0 do
    memo2.Lines.Add (memo1.Lines[i]) // in umgekehrter Reihenfolge in 2. Memo schieben
end;

end.

Der Rest, Exchange usw. und sonstige Verrenkungen sind eher entsetzlich.

[bluesbear]

Zitat von Hansa:

Der Rest, Exchange usw. und sonstige Verrenkungen sind eher entsetzlich.

Aber Hansa! Das irritiert mich jetzt. Das mit dem Exchange ist eine superelegante Lösung! Da müssen keine Speicherbereiche kopiert oder sonstwas gemacht werden, sondern nur ein paar Pointer vertauscht. Was schreibst denn Du da für einen... okok, ich werd wieder paranoid.

[DeddyH]

Das geht btw. auch ohne downto, indem man statt Add Insert an Position 0 anwendet

[Hansa]

Zitat von bluesbear:

...Exchange ist eine superelegante Lösung! Da müssen keine Speicherbereiche kopiert oder sonstwas gemacht werden, sondern nur ein paar Pointer vertauscht. Was schreibst denn Du da für einen... okok, ich werd wieder paranoid.

Jo. Siehe hier :

Delphi-Quellcode:

procedure TStringList.Exchange(Index1, Index2: Integer);
begin
  if (Index1 < 0) or (Index1 >= FCount) then Error(@SListIndexError, Index1);
  if (Index2 < 0) or (Index2 >= FCount) then Error(@SListIndexError, Index2);
  Changing;
  ExchangeItems(Index1, Index2);
  Changed;
end;

procedure TStringList.ExchangeItems(Index1, Index2: Integer);
var
  Temp: Integer;
  Item1, Item2: PStringItem;
begin
  Item1 := @FList^[Index1];
  Item2 := @FList^[Index2];
  Temp := Integer(Item1^.FString);
  Integer(Item1^.FString) := Integer(Item2^.FString);
  Integer(Item2^.FString) := Temp;
  Temp := Integer(Item1^.FObject);
  Integer(Item1^.FObject) := Integer(Item2^.FObject);
  Integer(Item2^.FObject) := Temp;
end;

So sieht das intern aus. Und elegant ist IMHO lesbarer Quelltext. Wer meine 7 relevanten Zeilen nicht versteht, der tut mir leid. Ergebnis : siehe Anhang.

[bluesbear]

Äh, ja. Ich gebs auf. Bin ich hier irgendeinem running gag zum Opfer gefallen?

[alzaimar]

Hansa, welche Methode ist eigentlich schneller? Deine in Fachkreisen genannte 'Downto'-Methode, oder das Vertauschen? Soweit ich mich erinnere, ging es im Post darum.

Zitat von Hansa:

Und elegant ist IMHO lesbarer Quelltext.

Den Quelltext der Exchange-Methode sieht man doch nicht.
Aber wenn Du schon so argumentierst, dann ist erstens jede Stringzuweisung unelegant, da der Compiler ja 'Magic' mit reincodiert, und zweitens die Add-Methode auch nicht gerade elegant. Da wird erst zu AddObject gesprungen, um dann zu InsertItem zu springen und dann wird u.U. erstmal der gesammte Speicher vergrößert und umkopiert, damit danach nochmal Speicher verschoben wird. Ahhhh ja., Äh.. *räusper*.. Elegant? Also, Hansa, ich weiss nicht.

Delphi-Quellcode:

function TStringList.Add(const S: string): Integer;
begin
  Result := AddObject(S, nil);
end;

function TStringList.AddObject(const S: string; AObject: TObject): Integer;
begin
  if not Sorted then
    Result := FCount
  else
    if Find(S, Result) then
      case Duplicates of
        dupIgnore: Exit;
        dupError: Error(@SDuplicateString, 0);
      end;
  InsertItem(Result, S, AObject);
end;

procedure TStringList.InsertItem(Index: Integer; const S: string; AObject: TObject);
begin
  Changing;
  if FCount = FCapacity then Grow;
  if Index < FCount then
    System.Move(FList^[Index], FList^[Index + 1],
      (FCount - Index) * SizeOf(TStringItem));
  with FList^[Index] do
  begin
    Pointer(FString) := nil;
    FObject := AObject;
    FString := S;
  end;
  Inc(FCount);
  Changed;
end;

Elegant sieht anders aus.

Zitat von Hansa:

Wer meine 7 relevanten Zeilen nicht versteht, der tut mir leid.

Och, das ist nicht das Problem. das Problem scheint zu sein, das Du die drei(!) relevanten Zeilen vom bluesbear, die zudem noch schneller sind, nicht als kürzer, schneller, leichter zu lesen und eleganter empfindest. Oder ist ein Codefragment mit mehr als doppelt so viel Zeilen, das lahm ist, etwa elegant?

Lern mal wieder argumentieren. So wird das nix mehr.