Ordenar Array de Registro por campo determinado

[roman]

Tendrías que completar tus tipos de datos con un apuntador al registro:

Código Delphi [-]
type
  PItem = ^TItem;
  TItem = record
    ...
  end;

Entonces, manejarías los elementos del TList así:

Código Delphi [-]
var
  Item: TItem;

begin
  // Agregar un item (la @ es para pasar un puntero al Item y no el Item en sí)
  Lista.Items.Add(@Item);

  // Tomar un item (haces el moldeo con PItem en lugar de TItem)
  Item := PItem(Lista.Items[i])^;
end;

// Saludos

[Bauhaus1975]

Hola de nuevo.
Entonces usando un puntero al registro. hmmm..., ¿quizá sea mejor usar un TObjectList?
y definir una clase que englobe al registro, lo digo por lo de ¿mejor usar objetos (nombres) que punteros?

Sí, ya sé que me pueden decir que mejor haber usado una clase para el tipo registro, pero resulta (lo típico) que el código ya está afectado de usar estos tipos.

Un saludo y gracias de nuevo.

[DarkMan]

Empezado por roman

Código Delphi [-]
 
var

  Item: TItem;
 
begin
  // Agregar un item (la @ es para pasar un puntero al Item y no el Item en sí)
  Lista.Items.Add(@Item);
 
  // Tomar un item (haces el moldeo con PItem en lugar de TItem)
  Item := PItem(Lista.Items[i])^;
end;

// Saludos

Una pequeña objección, este procedimiento sería incorrecto ya que Item es una variable local en este caso, y al ser un registro se elimina al finalizar la función. Al añadir su puntero a una lista de punteros, sólo podrás trabajar con él dentro de la propia función ya que después el item será eliminado. Una solución sería utilizar ficheros en lugar de Listas, utilizar una matriz global como habías comentado en el primer post, o cambiar el registro a clase.

Corregidme si me equivoco.

Un saludo.

[roman]

Es muy buena tu observación DarkMan. Habia puesto esa declaración ahí más que nada por fines informativos, para dejar claro el tipo de datos de Item. Pero lo cierto es que ni aun siendo una variable global tendría mucho sentido, pues no es cuestión de tener una variable por cada elemento de la lista.

Lo adecuado es crear dinámicamente los elementos que se insertan:

Código Delphi [-]
var
  Item: PItem; // Item es un puntero

begin
  New(Item);

  {
    Llenar ropiedades de Item:
    Item^.Campo1 := ...; 

    En delphi puede omitirse el operador de referencia ^
    Item.Campo2 := ...;
  }
  Lista.Add(Item); // Ojo, antes había puesto -incorrectamente- Lista.Items.Add
end;

Claro que, antes de destruir la lista, hay que recorrer sus elementos para liberar la memoria:

Código Delphi [-]
var
  I: Integer;

begin
  form I := 0 to Lista.Count - 1 do
    Dispose(Lista[i]);
end;

// Saludos

[Bauhaus1975]

Hola de nuevo y gracias a los dos por la ayuda.

Estoy ya implementando vuestros consejos, aunque como el código estaba muy extendido ya, me queda todavía, y no se aún si funciona. Me estoy planteando tener una función/ o método 'ordenar', que trate de manera aislada el TList para ordenar y luego devuelva una copia del TList pero pasado a 'array or record' que es lo que usa el resto de partes del programa.

Además, todavía me quedan algunas dudas...

1. Sobre la llamada a ordenar:

Código Delphi [-]
list.Sort(@compararCampo1);

¿Puedo pasar en vez de una función, un método de clase?
Also como '@self.compararCampo1'. Para no tener funciones sueltas. He probado pero no he conseguido salvar el error 'variable expected'.

2. Sobre el destruir items de la lista.

Empezado por roman

Código Delphi [-]
begin
  form I := 0 to Lista.Count - 1 do
          Dispose(Lista[i]);
end;

Roman, en vez de lo que comentas ¿no sería mejor lo siguiente?:

Código Delphi [-]
// O bien:
lista.Clear;
// O bien:
begin
  form I := 0 to Lista.Count - 1 do
          Dispose(Lista.items[i]);
          // incluso -> lista.Delete(i);
end;

También tengo otro problema, y es que tengo que almacenar cada Tlist que proceso en un array (array of TList). Resulta que cada vez que voy a procesar un nuevo TList, lo libero (reseteo), y pierdo lo que tenia almacenado en el array de TList de anteriores posiciones. Pero para no mezclar, esto lo trataré en un nuevo Post si es necesario.

Saludos.

[[Delphius]]

Empezado por Bauhaus1975

2. Sobre el destruir items de la lista.


Roman, en vez de lo que comentas ¿no sería mejor lo siguiente?:

Código Delphi [-]// O bien: lista.Clear; // O bien: begin form I := 0 to Lista.Count - 1 do Dispose(Lista.items[i]); // incluso -> lista.Delete(i); end;

Hola Bauhaus1975, no soy roman... mucho de lo que se vino hablando no tengo mucha idea, pero por lo que preguntas en el punto dos... creo que tengo la respuesta.

Si no me equivoco es indiferente. Tengo entendido que Items es la propiedad vectorial por defecto que tiene TList. Por ello es que es lo mismo: Lista[] que Lista.Items[].

Saludos,

[roman]

A ver, no nos confundamos. El método Lista.Delete borra un elemento de la lista, pero cada elemento es un puntero y Delete no libera la memoria a la que apunta el item, es decir, el registro creado con New. Por eso es necesario Dispose.

Igualmente, el método Lista.Clear únicamente borra cada item, pero sin liberar la memoria a la que apunta cada uno.

Por eso escribí: antes de destruir la lista. Es decir, tienes que hacer el Dispose de cada elemento, y posteriormente llamar a Lista.Free para borrar la lista y todos sus elementos.

En resumen: una cosa es el puntero y otra cosa es el bloque al que apunta el puntero.

// Saludos

[Bauhaus1975]

Hola de nuevo.
Ey Delphius, gracias por el apunte. Entendido, la liberación de memoria de cada elemento de la lista hay que programarla.

Y sobre pasar un método de clase ¿puede hacerse?:

Código Delphi [-]
// ¿Puede hacerse? Da error de variable expected
lista.Sort(@self.ordenarPorCampo);

Gracias y un saludo.