BEGIN
N:= 63579;
{= ΠΏΠΎΠ»ΡΡΠ΅Π½ΠΈΠ΅ ΠΏΠ°ΠΌΡΡΠΈ ΠΏΠΎΠ΄ Π΄ΠΈΠ½Π°ΠΌΠΈΡΠ΅ΡΠΊΠΈΠΉ ΠΌΠ°ΡΡΠΈΠ².. =}
GetMem(B, N*sizeof(boolean));
{= ΡΠ°Π±ΠΎΡΠ° Ρ ΠΌΠ°ΡΡΠΈΠ²ΠΎΠΌβ¦ =}
B^[3477]:= FALSE;
{= Π²ΠΎΠ·Π²ΡΠ°ΡΠ΅Π½ΠΈΠ΅ ΠΏΠ°ΠΌΡΡΠΈ Π² ΠΊΡΡΡ =}
{$IFDEF VER80}
FreeMem(B, N*sizeof(boolean));
{$ELSE}
FreeMem(B);
{$ENDIF}
END.
ΠΠ°ΡΡΠΈΠ² Π² Delphi
ΠΠΎΡ Π½Π΅ΡΠΊΠΎΠ»ΡΠΊΠΎ ΡΡΠ½ΠΊΡΠΈΠΉ Π΄Π»Ρ ΠΎΠΏΠ΅ΡΠ°ΡΠΈΠΉ Ρ Π΄Π²ΡΡ ΠΌΠ΅ΡΠ½ΡΠΌΠΈ ΠΌΠ°ΡΡΠΈΠ²Π°ΠΌΠΈ. Π‘Π°ΠΌΡΠΉ ΠΏΡΠΎΡΡΠΎΠΉ ΠΏΡΡΡ Π΄Π»Ρ ΡΠΎΠ·Π΄Π°Π½ΠΈΡ ΡΠΎΠ±ΡΡΠ²Π΅Π½Π½ΠΎΠΉ Π±ΠΈΠ±Π»ΠΈΠΎΡΠ΅ΠΊΠΈ. ΠΡΠΎΡΠ΅Π΄ΡΡΡ 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