Π§ΠΈΡ‚Π°ΠΉΡ‚Π΅ ΠΊΠ½ΠΈΠ³ΠΈ ΠΎΠ½Π»Π°ΠΉΠ½ Π½Π° Bookidrom.ru! БСсплатныС ΠΊΠ½ΠΈΠ³ΠΈ Π² ΠΎΠ΄Π½ΠΎΠΌ ΠΊΠ»ΠΈΠΊΠ΅

Π§ΠΈΡ‚Π°Ρ‚ΡŒ ΠΎΠ½Π»Π°ΠΉΠ½ Β«Π‘ΠΎΠ²Π΅Ρ‚Ρ‹ ΠΏΠΎ Delphi. ВСрсия 1.0.6Β». Π‘Ρ‚Ρ€Π°Π½ΠΈΡ†Π° 9

Автор Π’Π°Π»Π΅Π½Ρ‚ΠΈΠ½ ΠžΠ·Π΅Ρ€ΠΎΠ²

BEGIN

 N:= 63579;

 {= ΠΏΠΎΠ»ΡƒΡ‡Π΅Π½ΠΈΠ΅ памяти ΠΏΠΎΠ΄ динамичСский массив.. =}

 GetMem(B, N*sizeof(boolean));

 {= Ρ€Π°Π±ΠΎΡ‚Π° с массивом… =}

 B^[3477]:= FALSE;

 {= Π²ΠΎΠ·Π²Ρ€Π°Ρ‰Π΅Π½ΠΈΠ΅ памяти Π² ΠΊΡƒΡ‡Ρƒ =}

 {$IFDEF VER80}

  FreeMem(B, N*sizeof(boolean));

 {$ELSE}

  FreeMem(B);

 {$ENDIF}

END.

Массив в Delphi

Π Π°Π·Π΄Π΅Π» 1

Π’ΠΎΡ‚ нСсколько Ρ„ΡƒΠ½ΠΊΡ†ΠΈΠΉ для ΠΎΠΏΠ΅Ρ€Π°Ρ†ΠΈΠΉ с Π΄Π²ΡƒΡ…ΠΌΠ΅Ρ€Π½Ρ‹ΠΌΠΈ массивами. Π‘Π°ΠΌΡ‹ΠΉ простой ΠΏΡƒΡ‚ΡŒ для создания собствСнной Π±ΠΈΠ±Π»ΠΈΠΎΡ‚Π΅ΠΊΠΈ. ΠŸΡ€ΠΎΡ†Π΅Π΄ΡƒΡ€Ρ‹ SetV ΠΈ GetV ΠΏΠΎΠ·Π²ΠΎΠ»ΡΡŽΡ‚ Ρ‡ΠΈΡ‚Π°Ρ‚ΡŒ ΠΈ ΡΠΎΡ…Ρ€Π°Π½ΡΡ‚ΡŒ элСмСнты массива VArray (Π΅Π³ΠΎ Π’Ρ‹ ΠΌΠΎΠΆΠ΅Ρ‚Π΅ ΠΎΠ±ΡŠΡΠ²ΠΈΡ‚ΡŒ ΠΊΠ°ΠΊ ΡƒΠ³ΠΎΠ΄Π½ΠΎ). НапримСр:

type

 VArray : Array[1..1] of double;

var

 X: ^VArray;

 NR, NC: Longint;

begin

 NR:= 10000;

 NC:= 100;

 if AllocArray(pointer(X), N*Sizeof(VArray)) then exit;

 SetV(X^, NC, 2000, 5, 3.27);    { X[2000,5] := 3.27 }

end;


function AllocArray(var V: pointer; const N: longint): Boolean;

begin        {распрСдСляСм ΠΏΠ°ΠΌΡΡ‚ΡŒ для массива v Ρ€Π°Π·ΠΌΠ΅Ρ€Π° n}

 try

  GetMem(V, N);

 except

  ShowMessage('ΠžΠ¨Π˜Π‘ΠšΠ выдСлСния памяти. Π Π°Π·ΠΌΠ΅Ρ€:' + IntToStr(N));

  Result:= True;

  exit;

 end;

 FillChar(V^, N, 0);  {Π² случаС Π²ΠΊΠ»ΡŽΡ‡Π΅Π½ΠΈΡ Π΄Π»ΠΈΠ½Π½Ρ‹Ρ… строк заполняСм ΠΈΡ… нулями}

 Result:= False;

end;


procedure SetV(var X: Varray; const N,ir,ic: LongInt;const value: double);

begin    {заполняСм элСмСнтами Π΄Π²ΡƒΡ…ΠΌΠ΅Ρ€Π½Ρ‹ΠΉ массив x Ρ€Π°Π·ΠΌΠ΅Ρ€ΠΎΠΌ ? x n : x[ir,ic] := value}

 X[N*(ir-1) + ic]:= value;

end;


function GetV(const X: Varray; const N, ir,ic : Longint): double;

begin         {Π²ΠΎΠ·Π²Ρ€Π°Ρ‰Π°Π΅ΠΌ Π²Π΅Π»ΠΈΡ‡ΠΈΠ½Ρ‹ x[ir,ic] для Π΄Π²ΡƒΡ…ΠΌΠ΅Ρ€Π½ΠΎΠ³ΠΎ массива ΡˆΠΈΡ€ΠΈΠ½ΠΎΠΉ n столбцов}

 Result:= X[N*(ir-1) + ic];

end;

Π Π°Π·Π΄Π΅Π» 2

Π‘Π°ΠΌΡ‹ΠΉ простой ΠΏΡƒΡ‚ΡŒ – ΡΠΎΠ·Π΄Π°Ρ‚ΡŒ массив динамичСски

Myarray:= GetMem(rows * cols * sizeof(byte,word,single,double ΠΈ ΠΏΡ€.)

сдСлайтС Ρ„ΡƒΠ½ΠΊΡ†ΠΈΡŽ fetch_num Ρ‚ΠΈΠΏΠ°

function fetch_num(r,c:integer): single;


result:= pointer + row + col*rows

ΠΈ Π·Π°Ρ‚Π΅ΠΌ вмСсто myarray[2,3] Π½Π°ΠΏΠΈΡˆΠΈΡ‚Π΅

myarray.fetch_num(2,3)

помСститС эти Ρ„ΡƒΠ½ΠΊΡ†ΠΈΠΈ Π² ваш ΠΎΠ±ΡŠΠ΅ΠΊΡ‚ ΠΈ Ρ€Π°Π±ΠΎΡ‚Π° с массивами станСт пустячным Π΄Π΅Π»ΠΎΠΌ. Π― экспСримСнтировал с ΠΌΠ½ΠΎΠ³ΠΎΠΌΠ΅Ρ€Π½Ρ‹ΠΌΠΈ (Π²ΠΏΠ»ΠΎΡ‚ΡŒ Π΄ΠΎ 8) динамичСскими слоТными массивами ΠΈ эти Ρ„ΡƒΠ½ΠΊΡ†ΠΈΠΈ ΠΏΠΎΠΊΠ°Π·Π°Π»ΠΈ ΠΎΡ‚Π»ΠΈΡ‡Π½Ρ‹ΠΉ Ρ€Π΅Π·ΡƒΠ»ΡŒΡ‚Π°Ρ‚.

Π Π°Π·Π΄Π΅Π» 3

Π’ΠΎΡ‚ способ создания одно– ΠΈ Π΄Π²ΡƒΡ…ΠΌΠ΅Ρ€Π½Ρ‹Ρ… динамичСских массивов:

(*

--

–- ΠΌΠΎΠ΄ΡƒΠ»ΡŒ для создания Π΄Π²ΡƒΡ… ΠΎΡ‡Π΅Π½ΡŒ простых классов ΠΎΠ±Ρ€Π°Π±ΠΎΡ‚ΠΊΠΈ динамичСских массивов

--     TDynaArray   :  ΠΎΠ΄Π½ΠΎΠΌΠ΅Ρ€Π½Ρ‹ΠΉ массив

--     TDynaMatrix  :  Π΄Π²ΡƒΠΌΠ΅Ρ€Π½Ρ‹ΠΉ динамичСский массив

--

*)

unit DynArray;

INTERFACE

uses SysUtils;

Type TDynArrayBaseType = double;

Const vMaxElements  =  (High(Cardinal) – $f) div sizeof(TDynArrayBaseType);

{= Π³Π°Ρ€Π°Π½Ρ‚ΠΈΡ€ΡƒΠ΅Ρ‚ максимально Π²ΠΎΠ·ΠΌΠΎΠΆΠ½Ρ‹ΠΉ массив =}

Type

 TDynArrayNDX     =  1..vMaxElements;

 TArrayElements   =  array[TDynArrayNDX] of TDynArrayBaseType;

 {= самый большой массив TDynArrayBaseType, ΠΊΠΎΡ‚ΠΎΡ€Ρ‹ΠΉ ΠΌΡ‹ ΠΌΠΎΠΆΠ΅Ρ‚ ΠΎΠ±ΡŠΡΠ²ΠΈΡ‚ΡŒ =}

 PArrayElements   =  ^TArrayElements;

 {= ΡƒΠΊΠ°Π·Π°Ρ‚Π΅Π»ΡŒ Π½Π° массив =}


 EDynArrayRangeError  =  CLASS(ERangeError);


 TDynArray  =  CLASS

 Private

  fDimension: TDynArrayNDX;

  fMemAllocated: word;

  Function  GetElement(N: TDynArrayNDX): TDynArrayBaseType;

  Procedure SetElement(N: TDynArrayNDX; const NewValue: TDynArrayBaseType);

 Protected

  Elements : PArrayElements;

 Public

  Constructor Create(NumElements : TDynArrayNDX);

  Destructor Destroy; override;

  Procedure Resize(NewDimension : TDynArrayNDX); virtual;

  Property dimension: TDynArrayNDX read fDimension;

  Property Element[N : TDynArrayNDX] : TDynArrayBaseType read GetElement write SetElement; default;

 END;


Const

 vMaxMatrixColumns = 65520 div sizeof(TDynArray);

 {= построСниС ΠΌΠ°Ρ‚Ρ€ΠΈΡ†Ρ‹ класса с использованиСм массива ΠΎΠ±ΡŠΠ΅ΠΊΡ‚ΠΎΠ² TDynArray =}


Type

 TMatrixNDX  =  1..vMaxMatrixColumns;

 TMatrixElements  =  array[TMatrixNDX] of TDynArray;

 {= каТдая ΠΊΠΎΠ»ΠΎΠ½ΠΊΠ° ΠΌΠ°Ρ‚Ρ€ΠΈΡ†Ρ‹ Π±ΡƒΠ΄Π΅Ρ‚ динамичСским массивом =}

 PMatrixElements  =  ^TMatrixElements;

 {= ΡƒΠΊΠ°Π·Π°Ρ‚Π΅Π»ΡŒ Π½Π° массив указатСлСй… =}

 TDynaMatrix  =  CLASS

 Private

  fRows          : TDynArrayNDX;

  fColumns       : TMatrixNDX;

  fMemAllocated  : longint;

  Function GetElement(row: TDynArrayNDX; column: TMatrixNDX): TDynArrayBaseType;

  Procedure SetElement(row: TDynArrayNDX; column: TMatrixNDX; const NewValue: TDynArrayBaseType);

 Protected

  mtxElements: PMatrixElements;

 Public

  Constructor Create(NumRows : TDynArrayNDX; NumColumns : TMatrixNDX);

  Destructor Destroy; override;

  Property rows: TDynArrayNDX read fRows;

  Property columns: TMatrixNDX read fColumns;

  Property Element[row : TDynArrayNDX; column : TMatrixNDX] : TDynArrayBaseType read GetElement write SetElement; default;

 END;


IMPLEMENTATION

(*

 --

 --  ΠΌΠ΅Ρ‚ΠΎΠ΄Ρ‹ TDynArray

 --

*)

Constructor TDynArray.Create(NumElements : TDynArrayNDX);

BEGIN   {==TDynArray.Create==}

 inherited Create;

 fDimension:= NumElements;

 GetMem(Elements, fDimension*sizeof(TDynArrayBaseType));

 fMemAllocated:= fDimension*sizeof(TDynArrayBaseType);

 FillChar(Elements^, fMemAllocated, 0);

END;    {==TDynArray.Create==}


Destructor TDynArray.Destroy;

BEGIN   {==TDynArray.Destroy==}

 FreeMem(Elements, fMemAllocated);

 inherited Destroy;

END;    {==TDynArray.Destroy==}


Procedure TDynArray.Resize(NewDimension: TDynArrayNDX);

BEGIN   {TDynArray.Resize==}

 if (NewDimension < 1) then raise EDynArrayRangeError.CreateFMT('ИндСкс Π²Ρ‹ΡˆΠ΅Π» Π·Π° Π³Ρ€Π°Π½ΠΈΡ†Ρ‹ Π΄ΠΈΠ°ΠΏΠ°Π·ΠΎΠ½Π° : %d', [NewDimension]);

 Elements:= ReAllocMem(Elements, fMemAllocated, NewDimension*sizeof(TDynArrayBaseType));

 fDimension:= NewDimension;

 fMemAllocated:= fDimension*sizeof(TDynArrayBaseType);

END;    {TDynArray.Resize==}


Function  TDynArray.GetElement(N: TDynArrayNDX) : TDynArrayBaseType;

BEGIN   {==TDynArray.GetElement==}

 if (N < 1) OR (N > fDimension) then raise EDynArrayRangeError.CreateFMT('ИндСкс Π²Ρ‹ΡˆΠ΅Π» Π·Π° Π³Ρ€Π°Π½ΠΈΡ†Ρ‹ Π΄ΠΈΠ°ΠΏΠ°Π·ΠΎΠ½Π° : %d', [N]);

 result:= Elements^[N];

END;    {==TDynArray.GetElement==}


Procedure TDynArray.SetElement(N: TDynArrayNDX; const NewValue: TDynArrayBaseType);

BEGIN   {==TDynArray.SetElement==}

 if (N < 1) OR (N > fDimension) then raise EDynArrayRangeError.CreateFMT('ИндСкс Π²Ρ‹ΡˆΠ΅Π» Π·Π° Π³Ρ€Π°Π½ΠΈΡ†Ρ‹ Π΄ΠΈΠ°ΠΏΠ°Π·ΠΎΠ½Π° : %d', [N]);

 Elements^[N]:= NewValue;

END;    {==TDynArray.SetElement==}


(*

 --

 --  ΠΌΠ΅Ρ‚ΠΎΠ΄Ρ‹ TDynaMatrix

 --

*)

Constructor TDynaMatrix.Create(NumRows: TDynArrayNDX; NumColumns: TMatrixNDX);

Var col :  TMatrixNDX;

BEGIN   {==TDynaMatrix.Create==}

 inherited Create;

 fRows:= NumRows;

 fColumns:= NumColumns;

 {= Π²Ρ‹Π΄Π΅Π»Π΅Π½ΠΈΠ΅ памяти для массива ΡƒΠΊΠ°Π·Π°Ρ‚Π΅Π»Π΅ΠΉ (Ρ‚.Π΅. для массива TDynArrays) =}

 GetMem(mtxElements, fColumns*sizeof(TDynArray));

 fMemAllocated:= fColumns*sizeof(TDynArray);

 {= Ρ‚Π΅ΠΏΠ΅Ρ€ΡŒ выдСляСм ΠΏΠ°ΠΌΡΡ‚ΡŒ для ΠΊΠ°ΠΆΠ΄ΠΎΠ³ΠΎ столбца ΠΌΠ°Ρ‚Ρ€ΠΈΡ†Ρ‹ =}

 for col := 1 to fColumns do BEGIN

  mtxElements^[col]:= TDynArray.Create(fRows);

  inc(fMemAllocated, mtxElements^[col].fMemAllocated);

 END;

END;    {==TDynaMatrix.Create==}


Destructor  TDynaMatrix.Destroy;

Var col :  TMatrixNDX;

BEGIN   {==TDynaMatrix.Destroy;==}

 for col:= fColumns downto 1 do BEGIN

  dec(fMemAllocated, mtxElements^[col].fMemAllocated);

  mtxElements^[col].Free;

 END;

 FreeMem(mtxElements, fMemAllocated);

 inherited Destroy;

END;    {==TDynaMatrix.Destroy;==}


Function  TDynaMatrix.GetElement(row: TDynArrayNDX; column: TMatrixNDX): TDynArrayBaseType;

BEGIN   {==TDynaMatrix.GetElement==}

 if (row < 1) OR (row > fRows) then raise EDynArrayRangeError.CreateFMT('ИндСкс строки Π²Ρ‹ΡˆΠ΅Π» Π·Π° Π³Ρ€Π°Π½ΠΈΡ†Ρ‹ Π΄ΠΈΠ°ΠΏΠ°Π·ΠΎΠ½Π° : %d', [row]);

 if (column < 1) OR (column > fColumns) then raise EDynArrayRangeError.CreateFMT('ИндСкс столбца Π²Ρ‹ΡˆΠ΅Π» Π·Π° Π³Ρ€Π°Π½ΠΈΡ†Ρ‹ Π΄ΠΈΠ°ΠΏΠ°Π·ΠΎΠ½Π° : %d', [column]);

 result:= mtxElements^[column].Elements^[row];

END;    {==TDynaMatrix.GetElement==}


Procedure TDynaMatrix.SetElement(row: TDynArrayNDX; column: TMatrixNDX; const NewValue: TDynArrayBaseType);

BEGIN   {==TDynaMatrix.SetElement==}

 if (row < 1) OR (row > fRows) then raise EDynArrayRangeError.CreateFMT('ИндСкс строки Π²Ρ‹ΡˆΠ΅Π» Π·Π° Π³Ρ€Π°Π½ΠΈΡ†Ρ‹ Π΄ΠΈΠ°ΠΏΠ°Π·ΠΎΠ½Π° : %d', [row]);

 if (column < 1) OR (column > fColumns) then raise EDynArrayRangeError.CreateFMT('ИндСкс столбца Π²Ρ‹ΡˆΠ΅Π» Π·Π° Π³Ρ€Π°Π½ΠΈΡ†Ρ‹ Π΄ΠΈΠ°ΠΏΠ°Π·ΠΎΠ½Π° : %d', [column]);

 mtxElements^[column].Elements^[row]:= NewValue;

END;    {==TDynaMatrix.SetElement==}


END.

-ВСстовая ΠΏΡ€ΠΎΠ³Ρ€Π°ΠΌΠΌΠ° для модуля DynArray-

uses DynArray, WinCRT;

Const

 NumRows:  integer = 7;

 NumCols:  integer = 5;

Var

 M: TDynaMatrix;

 row, col: integer;

BEGIN

 M:= TDynaMatrix.Create(NumRows, NumCols);

 for row:= 1 to M.Rows do for col:= 1 to M.Columns do M[row, col]:= row + col/10;

 writeln('ΠœΠ°Ρ‚Ρ€ΠΈΡ†Π°');

 for row:= 1 to M.Rows do BEGIN

  for col:= 1 to M.Columns do write(M[row, col]:5:1);

  writeln;

 END;

 writeln;

 writeln('ΠŸΠ΅Ρ€Π΅ΠΌΠ΅Ρ‰Π΅Π½ΠΈΠ΅');

 for col:= 1 to M.Columns do BEGIN