Retonar arreglo dinamico en funcion

[BDWONG]

Bueno estaba mirando algo de poo en pascal y queria crear una funcion que me retornara
un arreglo intente poner la funcion y de retorno algo asi

function mifuncion:array of integer;
begin
end;

pero me daba error asi que cheque dos posible soluciones una declarar un nuevo tipo que fuera de array of integer
ejemplo

type
TIntegerArray:array of integer;

function mfuncion:TintegerArray;
begin
end;

y la otra solucion seria usar el Tarray<integer> como tipo de retorno la verdad me gusto mas la segunda opcion pero no se si estoy haciendo una buena implementacion ya que este Tarray<> tiene una serie funciones mas avanzadas

este codigo hice en delphi

Código Delphi [-]
unit Metodos;

interface

type
  TMetodo=class(TObject)
    private
    arreglo:Tarray;
    public
    constructor Create(tamano:integer);
    procedure LlenarArreglo;
    function  ObtenerArreglo():Tarray;
  end;


implementation

  constructor TMetodo.Create(tamano:integer);
  begin
     SetLength(self.arreglo,tamano);
  end;

  procedure TMetodo.LlenarArreglo;  {llenamos el arreglo}
  var
  i:integer;
  begin
    Randomize;
    for I := 0 to High(self.arreglo) do
    begin
        self.arreglo[i]:=Random(100);
    end;
  end;

  function TMetodo.ObtenerArreglo:Tarray;{RETORNAMOS el arreglo}
  begin
     if length(self.arreglo)>0 then
       result:=self.arreglo
     else
       result:=nil;
  end;

end.

entonces quiseira saber si es correcto como lo estoy haciendo
espero sus respuestas saludos...

[[gatosoft]]

Bueno, en principio, tu codigo funciona... aunque de acuerdo a o que hablaste, creo que omitiste la definición: <Integer>

Código Delphi [-]
  TMetodo=class(TObject)
    private
    arreglo:Tarray;
    public
    constructor Create(tamano:integer);
    procedure LlenarArreglo;
    function  ObtenerArreglo():Tarray;
  end;

Por otro lado... quisiera saber cual es el objetivo de tu clase tMetodo.. y cual es la necesidad que tienes... pues tengo algunas dudas sobre la forma como implementas, pero eso depende de tu necesidad.

Podrias por ejemplo, no utilizar TArray<Integer>, sino TList<T>...

Código Delphi [-]

Uses system.Generics.Collections;

TMyArreglo = Class(TList)
end;

Es una lista dinnámica con la que te evitas el SetLength... y puedes utilizar metodos como Add, Insert, Delete, sort.... Pero claro está eso depende de tu necesidad...

Con Generics vienen predefindas unas estructuras interesantes para trabajar Pilas, Colas, Estructuras clave/valor (diccionarios), entre otras.

TObjectList
TStack
TQueue
TDictionary

en general, lo que quiero decir es que hablar de array dinámicos hoy dia no es muy común...

saludo

[BDWONG]

la verdad tienes razon en lo Tarray<integer>

pero lo raro que yo en mi codigo si lo puse asi: Tarray<integer> no se si al momento de publicarlo se habra eliminado no lo se, ademas que que en un Tarray si no especificas de que tipo es te generar un error, inclusive si lo ocuparas con una variable de tipo variant

y el otro punto de cual era el objetivo, pues no existe alguno solo conocer en mas profunidad como funciona el lenguaje
ya que claro en esto tiempo seria mas optimo utilizar listas, pilas, colas etc.
pero solo seria probar si el retorno de la funcion seria lo mas ideal.

[ecfisa]

Hola.

Solo una aclaración sobre la devolución de arreglos dinámicos. Como está escrita la funcion ObtenerArreglo en el mensaje de BDWONG, no se obtendría una copia del arreglo sino un apuntador al arreglo como se puede comprobar con este ejemplo:

Código Delphi [-]
program Project2; {$APPTYPE CONSOLE}

uses
  SysUtils;

type
  TArray = array of Integer;

var
  vec: TArray;

// Devuelve apuntador
function RetArrayPtr: TArray;
begin
  Result:= vec;
end;

// Devuelve copia
function RetArray: TArray;
begin
  SetLength(Result, Length(vec));
  move(vec[0], Result[0], Length(vec)*Sizeof(Integer));
end;

var
  v1,v2: TArray;
  i: Integer;
begin
  SetLength(vec, 10);
  for i:= 0 to 9 do vec[i]:= i;

  v1:= RetArrayPtr;
  v2:= RetArray;

  Write('v1, apuntador:');
  for i:= 0 to 9 do write(v1[i]:3);
  Writeln;
  Write('v2, copia    :');
  for i:= 0 to 9 do write(v2[i]:3);
  Writeln;

  vec[0]:= 99;
  Writeln(#10#13+'Luego de modificar arreglo original'+#10#13);
  Write('v1, apuntador:');
  for i:= 0 to 9 do write(v1[i]:3);
  Writeln;
  Write('v2, copia    :');
  for i:= 0 to 9 do write(v2[i]:3);

  Finalize(vec);
  Finalize(v1);
  Finalize(v2);
  Readln;
end.

Saludos

[[Al González]]

Hola chicos.

Sólo agregar que las matrices (por muchos años les llamé arreglos) dinámicas, como también las cadenas de caracteres, utilizan contadores de referencias, por lo cual se copian automáticamente si y sólo si "algo" necesita una copia particular. Lo anterior ocurre, por ejemplo, cuando se agregan nuevos elementos a la matriz: sólo la variable usada en tal operación adquiere una copia, modificada, del contenido.

Eso hace de las matrices dinámicas una herramienta muy eficiente para el manejo colectivo de datos. Su uso está vigente en innumerables casos, y aunque existen clases más especializadas, no son nada obsoletas.

Saludos cordiales.

Al González.

P.D. Qué difícil es redactar desde un teléfono móvil.

[ecfisa]

Empezado por Al González

Eso hace de las matrices dinámicas una herramienta muy eficiente para el manejo colectivo de datos. Su uso está vigente en innumerables casos, y aunque existen clases más especializadas, no son nada obsoletas.

Totalmente de acuerdo , y realmente son una herramienta muy poderosa, también los uso a menudo.

Quizá fué mala elección usar el modo consola para representar el ejemplo dando así la impresión de que su uso es obsoleto. Pero es que me pareció mas claro de visualizar de ese modo, a ver si puedo enmendarlo un poco ...

Código Delphi [-]
{$WARNINGS OFF}
unit uDynArray;

interface

uses SysUtils, Classes;

type
  TElementType = Integer;
  TDynArray = array of TElementType;
  EDynRangeError = class(ErangeError);

  TClassDynArray = class(TObject)
  private
    FArray: TDynArray;
    FCount: Integer;
    FRandRange: Integer;
    function CheckInRange(Index: Integer): Boolean;
    function GetItem(index: Integer): TElementType;
    procedure SetItem(index: Integer; Value: TElementType);
    procedure QSortAsc(Left, Right: Integer);
    procedure QSortDes(Left, Right: Integer);
    function GetFArray: TDynArray;
  public
    constructor Create(NewLength: Integer=0);
    procedure RndFillArray;
    procedure Sort(const Ascending: Boolean=True);
    procedure Push(Value: TElementType);
    function Pop: TElementType;
    procedure Insert(Value: TElementType; Index: Integer);
    procedure InsertRange(Index: Integer; Values: array of TElementType);
    function IndexOf(Value: TElementType): Integer;
    procedure Delete(const Index: Integer);
    procedure DeleteRange(const a,b: Integer);
    procedure Swap(const a, b: Integer);
    procedure Increase(const Value: Integer);
    procedure Assign(DynArray: TDynArray);
    procedure FillZero;
    procedure Clear;
    //...
    destructor Destroy; override;
    property Count: Integer read FCount;
    property RandRange: Integer read FRandRange write FRandRange;
    property Items[index: Integer]: TElementType read GetItem write SetItem; default;
    property GetArray: TDynArray read GetFArray;
    //...
  end;

implementation

uses Windows;

// ------------------ public ------------------

constructor TClassDynArray.Create(NewLength: Integer);
begin
  Randomize;
  FRandRange:= 100;
  SetLength(FArray, NewLength);
  FCount:= NewLength;
end;

// Llena el arreglo con valores enteros de forma aleatoria
procedure TClassDynArray.RndFillArray;
var
  i: Integer;
begin
  for i:= 0 to FCount-1 do
    FArray[i]:= Random(FrandRange);
end;

// Agrega un elemento al final del arreglo
procedure TClassDynArray.Push(Value: TElementType);
begin
  SetLength(FArray, Length(FArray)+1);
  Inc(FCount);
  FArray[FCount-1]:= Value;
end;

// Extrae un elemento del final del arreglo
function TClassDynArray.Pop: TElementType;
begin
  Result:= FArray[FCount-1];
  Dec(FCount);
  SetLength(FArray, Length(FArray));
end;

// Inserta un elemento en la posición del índice
procedure TClassDynArray.Insert(Value: TElementType; Index: Integer);
var
  i: Integer;
begin
  if Index < 0 then
    raise EDynRangeError.Create('Índice fuera de rango');
  if Index > FCount then
    Push(Value)
  else
  begin
    SetLength(FArray, Length(FArray)+1);
    Inc(FCount);
    for i:= FCount-1 downto Index+1 do
      FArray[i]:= FArray[i-1];
    FArray[Index]:= Value;
  end;
end;

// Inserta un rango de valores en FArray
procedure TClassDynArray.InsertRange(Index: Integer; Values: array of TElementType);
var
  i: Integer;
begin
  for i:= Low(Values) to High(Values) do
    Insert(Values[i], i+1);
end;

// Devuelve el índice de la primera ocurrencia de Value
function TClassDynArray.IndexOf(Value: TElementType): Integer;
var
  i: Integer;
begin
  Result:= -1;
  for i:= 0 to FCount-1 do
    if FArray[i] = Value then
    begin
      Result:= i;
      Exit;
    end;
end;

// Elimina un elemento del arreglo
procedure TClassDynArray.Delete(const Index: Integer);
var
  i: Integer;
begin
  if FCount = 0 then
    raise EDynRangeError.Create('Arreglo vacío');
  if not CheckInRange(Index) then
    raise EDynRangeError.Create('Índice fuera de rango');
  for i:= Index to FCount-1 do FArray[i]:= FArray[i+1];
  Dec(FCount);
  SetLength(FArray, Length(FArray));
end;

// Elimina desde/hasta elementos del arreglo
procedure TClassDynArray.DeleteRange(const a, b: Integer);
var
  i: Integer;
begin
   if FCount = 0 then
    raise EDynRangeError.Create('Arreglo vacío');
  if not (CheckInRange(a)and(CheckInRange(b))) then
    raise EDynRangeError.Create('Índice fuera de rango');
  for i:= a to FCount-1 do
    FArray[i]:= FArray[b+i-1];
  Dec(FCount, Abs(a-b));
  SetLength(FArray, FCount)
end;

// Intercambia dos elementos del arreglo
procedure TClassDynArray.Swap(const a, b: Integer);
var
  aux: TElementType;
begin
  if not CheckInRange(a) or not CheckInRange(b) then
    EDynRangeError.Create('Indice fuera de rango');
  aux:= FArray[a];
  FArray[a]:= FArray[b];
  FArray[b]:= aux;
end;

// Llama a ordenamientos Asc o Desc acorde al valor del argumento
procedure TClassDynArray.Sort(const Ascending: Boolean=True);
begin
  if Ascending then
    QSortAsc(0, FCount-1)
  else
    QSortDes(0, FCount-1);
end;

// Aumenta el tamaño del arreglo
procedure TClassDynArray.Increase(const Value: Integer);
begin
  try
    SetLength(FArray, Length(FArray) + Value);
    Inc(FCount, Value);
  except
    raise EDynRangeError.Create('Memoria insuficiente');
  end;
end;

// Asigna un arreglo dinámico a FArray
procedure TClassDynArray.Assign(DynArray: TDynArray);
begin
  Clear;
  try
    FCount:= Length(DynArray);
    SetLength(FArray, FCount);
    move(DynArray[0], FArray[0], FCount*sizeof(TElementType));
  except
    raise EDynRangeError.Create('Memoria insuficiente');
  end;
end;

// Pone en cero los elementos del arreglo
procedure TClassDynArray.FillZero;
begin
  ZeroMemory(@FArray[0], Count*SizeOf(TElementType));
end;

// Elimina los elementos del arreglo
procedure TClassDynArray.Clear;
begin
  SetLength(FArray, 0);
end;

destructor TClassDynArray.Destroy;
begin
  Finalize(FArray);
  inherited;
end;

// ------------------ private ------------------

// Devuevelve el elemento indicado por el índice
function TClassDynArray.GetItem(index: Integer): TElementType;
begin
  if not CheckInRange(Index) then
    raise EDynRangeError.Create('Índice fuera de rango');
  Result:= FArray[index];
end;

// Asigna valor a un elemento del arreglo
procedure TClassDynArray.SetItem(index: Integer; Value: TElementType);
begin
  if not CheckInRange(Index) then
    raise EDynRangeError.Create('Índice fuera de rango');
  if FArray[index] <> Value then
    FArray[index]:= Value;
end;

// Devuelve False si el índice esta fuera del rango
function TClassDynArray.CheckInRange(Index: Integer): Boolean;
begin
  Result:= (Index >= 0) or (Index < FCount-1);
end;

// Ordena ascendente
procedure TClassDynArray.QSortAsc(Left, Right: Integer);
var
   i, j, mid: Integer;
begin
  i := Left;
  j := Right;
  mid := FArray[(Left+Right) div 2];
  repeat
    while FArray[i] < mid do Inc(i);
    while Farray[j] > mid do Dec(j);
    if i <= j then
    begin
      Swap(i, j);
      Inc(i);
      Dec(j);
    end;
  until i > j;
  if j > Left then QSortAsc(Left, j);
  if i < Right then QSortAsc(i, Right);
end;

// Ordena descendente
procedure TClassDynArray.QSortDes(Left, Right: Integer);
var
  i, j, mid : Integer;
begin
  i:= Left;
  j:= Right;
  mid := FArray[(Left+Right) div 2];
  repeat
    while FArray[i] > mid do Inc(i);
    while FArray[j] < mid do Dec(j);
    if i <= j then
    begin
      Swap(i, j);
      Inc(i);
      Dec(j);
    end;
  until i >= j;
  if j > Left then QSortDes(Left, j);
  if i < Right then QSortDes(i, Right);
end;

// Devuelve una copia del arreglo
function TClassDynArray.GetFArray: TDynArray;
begin
  try
    SetLength(Result, FCount);
    move(FArray[0], Result[0], FCount*sizeof(TElementType));
  except
    raise EDynRangeError.Create('Memoria insuficiente');
  end;
end;
end.

Y se le puede ir agregando las funcionalidades que se nos vayan ocurriendo.

Empezado por Al González

P.D. Qué difícil es redactar desde un teléfono móvil.

De echo yo no me animo

Saludos

[[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.