Zugriffsverletzung?

[Perlsau]

Da hast du auch wieder recht
Man kann das aber umgehen, indem man einfach alle Strings vor dem Setzen des Sorted-Properties mit der entsprechenden Anzahl von '0' ergänzt

Delphi-Quellcode:

Function FillString(Quelle : String; Zeichen : Char; Anzahl : Integer; Anfang : Boolean) : String;
Var
  Fuellung : String;

begin
  Result := '';
  IF Quelle = '' THEN Exit;
  Anzahl := Anzahl - Length(Quelle);
  IF Anzahl < 1 THEN Exit;

  Fuellung := '' + Zeichen;
  Fuellung := StrUtils.DupeString(Fuellung,Anzahl);
  IF Anfang THEN
     Result := Fuellung + Quelle ELSE
     Result := Quelle + Fuellung;
end;

Function SortiereZahlen(Eingabe : String) : String;
Var
  MyList : TSTringList;
  i : Integer;

Begin
  Result := '';
  MyList := TStringList.Create;
  MyList.Delimiter := ',';
  MyList.StrictDelimiter := True;

  Try
    MyList.DelimitedText := Eingabe;

    For i := 0 to MyList.Count -1 DO MyList[i] := FillString(MyList,'0',10,True);

    MyList.Sorted := True;
    Result := MyList.DelimitedText;
  Finally
    MyList.Free;
  End;

Benötigt man die im Rückgabe-String enthaltenen Zahlen danach als Integer-Werte, kann man ohne Probleme die mit voranstehenden Nullen ergänzten Strings zum Umwandeln in Integer verwenden, andernfalls müßte man die Nullen wieder entfernen.

[Sir Rufo]

Ich hätte da eher an so etwas gedacht

Delphi-Quellcode:

program dp_178240;

{$APPTYPE CONSOLE}
{$R *.res}
{.$DEFINE USE_TYPES}

uses
{$IFDEF USE_TYPES}
  Types, // Gibt es ab Delphi XE ???
{$ENDIF}
  Classes,
  SysUtils;

{$IFNDEF USE_TYPES}

type
  TIntegerDynArray = array of Integer;
{$ENDIF}

function StrToIntArray( const AStr : string; const ADelimiter : Char ) : TIntegerDynArray;
  var
    LStrings : TStrings;
    LIdx     : Integer;
  begin
    LStrings := TStringList.Create;
    try
      LStrings.Delimiter     := ADelimiter;
      LStrings.DelimitedText := AStr;
      SetLength( Result, LStrings.Count );

      for LIdx := 0 to LStrings.Count - 1 do
        begin
          Result[LIdx] := StrToInt( LStrings[LIdx] );
        end;
    finally
      LStrings.Free;
    end;
  end;

function IntArrayToStr( const AIntArray : TIntegerDynArray; const ADelimiter : Char ) : string;
  var
    LStrings : TStrings;
    LIdx     : Integer;
  begin
    LStrings := TStringList.Create;
    try
      LStrings.Delimiter := ADelimiter;

      for LIdx := low( AIntArray ) to high( AIntArray ) do
        begin
          LStrings.Add( IntToStr( AIntArray[LIdx] ) );
        end;

      Result := LStrings.DelimitedText;
    finally
      LStrings.Free;
    end;
  end;

procedure SortIntArray( var AIntArray : TIntegerDynArray );
  var
    LCurrent : Integer;
    LCompare : Integer;
    LTemp    : Integer;
  begin
    // Simple Bubble-Sort algo
    for LCurrent := low( AIntArray ) to high( AIntArray ) - 1 do
      begin
        for LCompare := LCurrent + 1 to high( AIntArray ) do
          begin
            if AIntArray[LCurrent] > AIntArray[LCompare]
            then
              begin
                LTemp               := AIntArray[LCurrent];
                AIntArray[LCurrent] := AIntArray[LCompare];
                AIntArray[LCompare] := LTemp;
              end;
          end;
      end;
  end;

function SortIntArrayStr( const AStr : string; const ADelimiter : Char = ',' ) : string;
  var
    LIntArray : TIntegerDynArray;
  begin
    LIntArray := StrToIntArray( AStr, ADelimiter );
    SortIntArray( LIntArray );
    Result := IntArrayToStr( LIntArray, ADelimiter );
  end;

procedure Test;
  var
    LTest : string;
  begin
    LTest := '7,3,11,5,1';
    Writeln( LTest, ' => ', SortIntArrayStr( LTest ) );
  end;

begin
  try
    Test;
  except
    on E : Exception do
      Writeln( E.ClassName, ': ', E.Message );
  end;

  ReadLn;

end.

Jede Funktion/Prozedur erledigt genau eine Aufgabe. Dadurch bleiben diese übersichtlich, wiederverwend-, test- und wartbar.

[Sir Rufo]

Zitat von Perlsau:

Da hast du auch wieder recht
Man kann das aber umgehen, indem man einfach alle Strings vor dem Setzen des Sorted-Properties mit der entsprechenden Anzahl von '0' ergänzt

Das geht doch aber auch erheblich einfacher (mit TStringList) auch ohne durch die Brust ins Auge und zurück

Delphi-Quellcode:

// Nur mit TStringList

function StringListIntSort( List : TStringList; Index1, Index2 : Integer ) : Integer;
  begin
    Result := StrToInt( List[Index1] ) - StrToInt( List[Index2] );
  end;

function SortIntArrayStr( const AStr : string; const ADelimiter : Char = ',' ) : string;
  var
    LStrings : TStringList;
  begin
    LStrings := TStringList.Create;
    try
      LStrings.Delimiter     := ADelimiter;
      LStrings.DelimitedText := AStr;

      LStrings.CustomSort( StringListIntSort );

      Result := LStrings.DelimitedText;
    finally
      LStrings.Free;
    end;
  end;