How can I use pointers to access the value of a dmArray = TList<dmRecord> record?

[skyzoframe[hun] 4]

Greetings everyone,

I want to sort a tList with some kind of record parameter. Somehow I need to use pointers to get to the record without using the name of the record.

In this example I am using the name "Rec.x". However, in the future I would like to use "Rec.y", "Rec.z","Rec.ID" or any other record value in the sort. // See below

In fact, I have never used pointers before.

 

"function Foo.BubbleSort(AList: dmA00; SomeParameterHere:IsSomething ;out Error: String): Boolean;"

...

" if jRec.SomeParameterHere > j1Rec.SomeParameterHere then"

 

kind regards Zoltan.K

 

  type
    dmR00 = Record
      ID : integer;
      x,y,z : integer;
    End;
...
dmA00 = TList<dmR00>;
...
  
function Foo.BubbleSort(AList: dmA00; out Error: String): Boolean;
  var
    jRec, j1Rec: dmR00;
    i,j : integer;
begin
  try
    for i := 0 to AList.Count - 2 do
    begin
      for j := 0 to AList.Count - 2 - i do
      begin
        // clear record
        jRec  :=  default(dmR00);
        j1Rec  :=  default(dmR00);
        // fill record
        jRec := aList[j];
        j1Rec := aList[j+1];
        // check record
        if jRec.x > j1Rec.x then
        begin
          AList[j] := j1Rec;
          AList[j + 1] := jRec;
        end;
      end;
    end;
    Result := True; 
  except
  on E: Exception do
    begin
      Error := ('Exception class name = ' + E.ClassName + sLineBreak +
        'Exception message = ' + E.Message);
      Result := False;
    end;
  end;
end;  

 

[Anders Melander 1933]

It's not clear to me what exactly you are doing but you can use TList<T>.List to get access to the internal dynamic array of TList<T>. From there you can create a pointer to the individual elements in the array:

type
  TMyRecord = record
    Foo: integer;
    Bar: string;
  end;

  PMyRecord = ^TMyRecord;

begin
  var MyList := TList<TMyRecord>.Create;
  ...

  // Get a reference to the internal dynamic array.
  // Note that this reference, and any pointers to the elements in
  // it, are only valid as long as the list size remains static;
  // Once you clear the list or add items to it, the references are 
  // stale becuase the internal array can be reallocated.
  var Items := MyList.List;
    
  // Get a pointer to an element in the array
  var SomeItem: PMyRecord := @Items[0];
  
  // Clear the element
  SomeItem^ := Default(TMyRecord);
  
  // Modify the element
  SomeItem.Foo := 42;
  SomeItem.Bar := 'Hello world';
end;

 

I assume your bubble sort is just an example. Otherwise, use TList<T>.Sort to sort the list.

 

Edited 3 hours ago by Anders Melander

[skyzoframe[hun] 4]

Yes, it is just an example.

 

I wanted to get to the record-element. With the help of pointers. But it is not clear to me how to do it. I have no idea if it will be possible.
Alternative solution can be a key-parameter, and each sorting record element I can handle with case statement.

 

 

type
    dmR00 = Record
      	ID : integer;//key-0
      	x,//key-1
      	y,//key-2
      	z : integer;//key-3
    End;
...
dmA00 = TList<dmR00>;
...
  
function Foo.BubbleSort(AList: dmA00; key:byte; out Error: String): Boolean;
  var
    jRec, j1Rec: dmR00;
    i,j : integer;
begin
  try
    for i := 0 to AList.Count - 2 do
    begin
      for j := 0 to AList.Count - 2 - i do
      begin
        // clear record
        jRec  :=  default(dmR00);
        j1Rec  :=  default(dmR00);
        // fill record
        jRec := aList[j];
        j1Rec := aList[j+1];
        // check record
  
        case key of
          0: begin
          if jRec.ID > j1Rec.ID then
            begin
              AList[j] := j1Rec;
              AList[j + 1] := jRec;
            end;
          end;
          1: begin
          if jRec.x > j1Rec.x then
            begin
              AList[j] := j1Rec;
              AList[j + 1] := jRec;
            end;
          end;
          2: begin
          if jRec.y > j1Rec.y then
            begin
              AList[j] := j1Rec;
              AList[j + 1] := jRec;
            end;
          end;
          3: begin
          if jRec.z > j1Rec.z then
            begin
              AList[j] := j1Rec;
              AList[j + 1] := jRec;
            end;
          end;
        end;
  	  end;
    end;
    Result := True; 
  except
  on E: Exception do
    begin
      Error := ('Exception class name = ' + E.ClassName + sLineBreak +
        'Exception message = ' + E.Message);
      Result := False;
    end;
  end;
end;  

 

 

 

 

 

 

 

 

[PeterBelow 248]

3 hours ago, skyzoframe[hun] said:

Greetings everyone,

I want to sort a tList with some kind of record parameter. Somehow I need to use pointers to get to the record without using the name of the record.

In this example I am using the name "Rec.x". However, in the future I would like to use "Rec.y", "Rec.z","Rec.ID" or any other record value in the sort. // See below

In fact, I have never used pointers before.

 

"function Foo.BubbleSort(AList: dmA00; SomeParameterHere:IsSomething ;out Error: String): Boolean;"

...

" if jRec.SomeParameterHere > j1Rec.SomeParameterHere then"

 

kind regards Zoltan.K

 

 

A TList<T> has a constructor overload that takes a comparer (IComparer<T> instance) to use for sorting and searching the list by default. The Sort method also has such an overload. You use

TComparer<T>.Construct() 

to fabricate a suitable comparer on the fly, providing an anonymous method that does the actual comparison of two items in the way you want the sort to go. This anonymous method has to "know" the record type in question, so you can directly refer to the fields of the two items passed to it.

 

Forget about pointers, you do not need them to work with generics.