1:
2:
3:
4:

function Sortieren_1(item1,item2:pointer):integer;
begin
    result := AnsiCompareText(TMyObject(item1).Prop1, TMyObject(item2).Prop1);
end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:

function Sortieren_1_2(item1,item2:pointer):integer;
var tmp:integer;
begin
  tmp := AnsiCompareText(TMyObject(item1).Prop1, TMyObject(item2).Prop1);
  // Wenn Vergleich nach Eigenschaft1 keine Unterscheidung liefert,
  // Dann Eigenschaft2 für größer/kleiner nehmen
  if tmp = 0 then
      result := AnsiCompareText(TMyObject(item1).Prop2, TMyObject(item2).Prop2)
  else result:=tmp;
end;                    

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:

const
  Strs  = 13; //max Strs.
  Ints  =  1; //max Strs.
  Bools =  1; //max Strs.
  StrsTitle       =  0;
  StrsArtist      =  1;
  StrsAlbum       =  2;
  StrsGenre       =  3;
  StrsYear        =  4;
  StrsComment     =  5;
  StrsComposer    =  6;
  StrsEncoder     =  7;
  StrsCopyright   =  8;
  StrsLanguage    =  9;
  StrsLink        = 10;
  StrsFormat      = 11;
  StrsFileFolder  = 12;
  StrsFileName    = 13;

  IntsTrack       =  0;
  IntsFileSize    =  1;

  BoolsDefect     =  0;
  BoolsSelected   =  1;

type
  TMusicInfo = record
    Strs:  array[0..Strs ] of String;
    Ints:  array[0..Ints ] of Integer; //die lasse ich im Bsp. jetzt mal außen vor, da musst du im Sort array eben noch einspeichern, welcher Typ es ist
    Bools: array[0..Bools] of Boolean;
  end;                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

function Sortieren_1(item1,item2:pointer):integer;
var
  i: integer;
begin
  result:=0;
  i:=0;
  while (result=0) and (i<MaxPropertys) do //MaxPropertys = soviele eigenschaften wie es gibt
  begin
    result := AnsiCompareText(TMyObject(item1).Strs[Sort[i]], TMyObject(item2).Strs[Sort[i]]);
    inc(i);
  end;
end;                    

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:

Es bei Item1, Item2 eine Pointer auf das Objekt uebergeben.
Die CompFunc muss sich die gewuenschten Properties kennen.(Also geht auch Objekt.Eigenschaft1 vergleichen mit Objekt2.Eigenschaft7)

type
  TCompFunc = function(Item1,Item2:Pointer):integer;
  TCompArrItem = record
                   CompFunc:TCOmpFunc;
                   inverted : integer;{=1 oder -1}
                 end;
  TCompArray = array of TCompArrItem;
{
function CompFuncEig47_11 :TCompFunc;
begin
  result := TMyObject(item1).Prop47-TMyObject(item2).Prop11;
end;

function CompFuncEig08_15 :TCompFunc;
begin
  result:= 1;
  IF NOT(TMyObject(item1).Prop08)OR TMyObject(item2).Prop15 then
     result := 0
  else
     IF NOT(TMyObject(item1).Prop08)XOR TMyObject(item2).Prop15 then
       result := -result;    
end;

function CompFuncEig2_103 :TCompFunc;
begin
  result := AnsiCompareText(TMyObject(item1).Prop2, TMyObject(item2).Prop103);
end;
}

function CompFunc_Multi(item1,item2:pointer;CompArray:TCompArray):integer;
var
  I :integer;
begin
  result := 0;//Falls Liste leer aendere nichts
  I := 0;
  while i< length(CompArray) do
    begin
    with CompArray[i] do
       result := CompFunc(item1,item2)*inverted;//*inverted ist wohl schneller als ein zusaetzlicher Vergleich
    IF result <> 0 then
      BREAK;
    inc(i);
    end;
end;                    

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:

    void radixMSD(Item a[], int iLinks,
                  int iRechts, int d) {

        int i, j, count[R];
        // maxN = Anzahl der Items in a
        Item aux[maxN];

        if (iRechts - iLinks <= M)
        {   // mit Insertionsort weitermachen
            insertion(a, iLinks, iRechts);
            return;
        }

        for (j = 0; j < R; j++)
            count[j] = 0;
        for (i = iLinks; i <= iRechts; i++)
            count[digit(a[i], d)]++;
        for(j = 1; i < R; j++)
            count[j] += count[j - 1];

        for (i = iLinks; i <= iRechts; i++)
            aux[iLinks+count[digit(a[i], d)]++] =
                a[i];

        for i = iLinks; i <= iRechts, i++)
            a[i] = aux[i];

        for (j = 0; i < R-1; j++)
            radixMSD(a, iLinks+count[j],
                     iLinks+count[j+1] - 1, d + 1);
    }                    

1:
2:
3:

// im Create des Objektes:
Str[StrArtist] absolute = Artist;
Str[StrAlbum] absolute = Album;                    

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:

  TTags = class(TObject)
    FTest: Integer;
    FArtist: AnsiString;
    FTitle : AnsiString;
  end;

  TStrAr = array[0..1] of AnsiString;
  PStrAr = ^TStrAr;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var
  Tags: TTags;
  test: PStrAr;
begin
  Tags:=TTags.Create;
  Tags.FTest:=4;
  Tags.FArtist:='Artist';
  Tags.FTitle:='Title';
  test:=Pointer(@Tags.FArtist);
  ShowMessage(test^[0]+' '+test^[1]);
  Tags.Free;
end;