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 2 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;