Retonar arreglo dinamico en funcion

[[Al González]]

Empezado por ecfisa

Quizá fué mala elección usar el modo consola para representar el ejemplo dando así la impresión de que su uso es obsoleto.

Despreocúpate ecfisa, tu código siempre me ha parecido enriquecedor. Fue gatosoft quien al parecer apuntaba lo de la obsolescencia (quizá me equivoco).

[[Al González]]

Me he permitido elaborar un par de ejemplos sobre la asignación de matrices dinámicas (dynamic arrays). Van a perdonar las posibles faltas ortográficas, pero es que mi Word se trabó.

Código Delphi [-]
Type
  TDynArray = Array Of Integer;

Var
  // Variable global de prueba A1 (ver sección Initialization al final)
  A1 :TDynArray;

// Ejemplo 1
procedure TForm1.Button1Click(Sender: TObject);
Var
  A2 :TDynArray;
begin
  { Asignamos la matriz A1 a A2.  Ambas variables apuntarán a la misma
    región de memoria, la cual cambia su contador de referencias interno de
    1 a 2 (ahora hay dos variables apuntando a ella). }
  A2 := A1;

  { Aumentamos a 6 la longitud de la matriz A2.  Esto implícitamente
    genera una copia de los elementos desde A [0] hasta A [4] a una nueva
    región de memoria, y A2 apuntará a ésta, mientras que A1 seguirá
    apuntando a la matriz original de 5 elementos, la cual reduce su
    contador de referencias a 1 (de nuevo sólo A1 apunta a ella). }
  SetLength (A2, 6);
  ShowMessage (Format ('Longitud de A1: %d', [Length (A1)]));
  ShowMessage (Format ('Longitud de A2: %d', [Length (A2)]));

  { Modificamos el primer elemento de A2 y lo mostramos en contraste con el
    primer elemento de A1 }
  A2 [0] := 30;
  ShowMessage (IntToStr (A1 [0]));  // Muestra 10 (de la original)
  ShowMessage (IntToStr (A2 [0]));  // Muestra 30 (de la copia modificada)

  // Mostramos el quinto elemento de A1 y el quinto elemento de A2
  ShowMessage (IntToStr (A1 [4]));  // Muestra 14 (de la original)
  ShowMessage (IntToStr (A2 [4]));  // Muestra 14 (de la copia)

  { Las variables que usan contadores de referencias se desechan en
    automático al quedar fuera de alcance.  En este "end", la región de
    memoria a la que apunta A2 será liberada por la así llamada "magia del
    compilador" (el compilador agrega al código máquina las instrucciones
    necesarias para ello). } 
end;

// Ejemplo 2
procedure TForm1.Button2Click(Sender: TObject);
Var
  A2 :TDynArray;
begin
  { Como ya vimos, esta asignación hace que ambas variables apunten a la
    misma región de memoria. }
  A2 := A1;

  { Pero si queremos una copia particular de la matriz dinámica, en lugar
    de asignación directa debemos usar la función estándar Copy. }
  A2 := Copy (A1);

  // Demostramos que realmente se trata de una copia
  A2 [0] := 30;
  ShowMessage (IntToStr (A1 [0]));  // Muestra 10 (de la original)
  ShowMessage (IntToStr (A2 [0]));  // Muestra 30 (de la copia modificada)
end;
                          
Initialization
  { Al comienzo del programa, asignamos memoria a la variable global A1
    para que contenga cinco números Integer (el tipo de nuestro TDynArray),
    y establecemos los valores 10, 11, 12, 13 y 14 en esa matriz.  NOTA:
    Esto está hecho en Delphi 7, pero al parecer desde la versión XE7 puede
    inicializarse una matriz dinámica en su propia declaración como
    variable global (nos ahorraríamos esta sección). }
  SetLength (A1, 5);
  A1 [0] := 10;
  A1 [1] := 11;
  A1 [2] := 12;
  A1 [3] := 13;
  A1 [4] := 14;

end.

Una aclaración que considero importante: A diferencia de las cadenas de caracteres, las matrices dinámicas no emplean el mecanismo de "copiar al escribir", por lo cual es necesario asegurarnos de tener una copia verdadera antes de hacer algo como:

Código Delphi [-]
A2 [0] := 30

Las funciones SetLength y Copy garantizan lo anterior.

Un saludo.

Al González.

[[nlsgarcia]]

BDWONG,

Empezado por BDWONG

...Retornar arreglo dinámico en función...conocer en mas profundidad como funciona el lenguaje Delphi...

Revisa este código:

Código Delphi [-]
unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Generics.Defaults, Generics.Collections;

type
  TForm1 = class(TForm)
    Button1: TButton;
    ListBox1: TListBox;
    ListBox2: TListBox;
    ListBox3: TListBox;
    ListBox4: TListBox;
    Label1: TLabel;
    Label2: TLabel;
    Label3: TLabel;
    Label4: TLabel;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
  public
    { Public declarations }
  end;

  TIntegerComparer = TComparer;

var
  Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
type
   TArrayInteger = Array of Integer;

   function FillArray(const InputArray : TArrayInteger) : TArrayInteger;
   var
      i : Integer;
   begin
      Randomize;
      SetLength(Result,Length(InputArray));
      for i:= Low(InputArray) to High(InputArray) do
         Result[i] := InputArray[i] + Random(1000);
   end;

var
   A1, A2, A3, A4 : TArrayInteger;
   i,p : Integer;
   MsgUser : String;
   SearchElement : Integer;
   Comparer: IComparer;

begin

   // Inicializa los ListBox
   ListBox1.Clear;
   ListBox2.Clear;
   ListBox3.Clear;
   ListBox4.Clear;

   // Inicializa los Arreglos Dinámicos A1, A2 y A3
   A1 := [2,1,5,3,4];
   A2 := [19,21,78,15,14];
   A3 := A1;

   // Inserta A2 al final de A3
   Insert(A2,A3,Length(A3));

   // Adiciona 4 elementos a A3
   A3 := A3 + [900,800,700,600];

   // Borra 2 elementos de A3
   Delete(A3,Length(A3)-4,2);

   // Muestra en el Lisboxt1 el arreglo A3 ordenado en modo ascencente

   TArray.Sort(A3); // Sort Ascencente

   for i := Low(A3) to High(A3) do
      ListBox1.Items.Add(IntToStr(A3[i]));

   // Muestra en el Lisboxt2 el arreglo A3 ordenado en modo descendente

   Comparer := TDelegatedComparer.Create(
               function(const Left, Right: Integer) : Integer
               begin
                  Result := Right - Left; // Sort Descendente
               end);

   TArray.Sort(A3, Comparer); // Sort Descendente

   for i := Low(A3) to High(A3) do
      ListBox2.Items.Add(IntToStr(A3[i]));

   // Muestra en el Lisboxt3 el arreglo A3 ordenado en modo ascendente con dos nuevos elementos

   SetLength(A3,Length(A3) + 2);
   for i := Length(A3)-2 to High(A3) do
      A3[i] := 7777 + i;

   TArray.Sort(A3);

   for i := Low(A3) to High(A3) do
      ListBox3.Items.Add(IntToStr(A3[i]));

   // Muestra en el Lisboxt4 el arreglo A4 creado en función de A3 en modo descendente

   A4 := FillArray(A3);

   TArray.Sort(A4, Comparer);

   for i := Low(A4) to High(A4) do
      ListBox4.Items.Add(IntToStr(A4[i]));

   // Realiza una búsqueda binaria en A3 y muestra el resultado

   SearchElement := 21;

   if TArray.BinarySearch(A3,SearchElement,p) then
   begin
      MsgUser := Format('El Elemento %d se encuentra en la Posición %d del Array A3 Modo-1',
                        [SearchElement,p]);
      MessageDlg(MsgUser,mtInformation,[mbOK],0);
   end;

   // Liberara los recursos de A1, A2, A3 y A4
   Finalize(A1);
   Finalize(A2);
   Finalize(A3);
   Finalize(A4);

end;

end.

El código anterior en Delphi XE7 sobre Windows 8.1 Professional x32, ejemplifica el uso de arreglos dinámicos en Delphi XE7, según se muestra en la siguiente imagen:



Espero sea útil

Nelson.