Dinamik bir diziyi implement etmede izlediğim yol şuydu;
Dinamik bellek yöneten fonksiyonları kullanarak, hafızada bir alan tahsis (allocate) etmek ve sonra, fonksiyonun döndürdüğü adres üzerinden hesaplama yaparak ilgili veriye ulaşmakdı.
Çıkardığım hesaplama formülü ise aşağıdaki gibiydi;
Basit bir hesap ile formülümüz aşağıdaki gibi olacaktır.
Kaç Bayt = index X Veri tipinin kapladığı alan(Byte)
Yeni Adres = Başlangıç adresi + Kaç Byte
Biraz düşünmeyle bulduğum bu formül, sadece 1 boyutlu bir dizinin elemanlarına erişim formülüydü. Şöyle ki;
Element_Adress = Base_Adress + (Index * Element_Size)
Memory_Size = Element_Count * Element_Size
Sonrasında ise Tuğrul hocamın (Write Great Code: Volume 1: Write Great Code, Write Great Code, Volume 2: Thinking Low-Level, Writing High-Level) kitaplarını kabaca incelerken, "Composite Data Types and Memory Objects" konusu gözüme çarptı ve doğrudan o konuyu incelemeye başladım.Kadere bakın ki; Pointer'lar, diziler ve çok boyutlu dizilerin elemanlarına erişim formülü yer alıyordu. :)
2 Boyutlu Dizi Ve Elemanlarına Erişim Formülü
Element_Adress = Base_Adress + (Col_Index * Row_Size + Row_Index) * Element_SizeMemory_Size = Element_Size * (Col_Count * Row_Count)
3 Boyutlu Dizi ve Elemanlarına Erişim Formülü
Element_Adress = Base_Adress + ( (Depth_Index * Col_Size + Col_Index) * Row_Size + Row_Index) * Element_SizeMemory_Size = Element_Size * Depth_Size * (Col_Count * Row_Count)
Element_Adress hafıza bloğundaki verinin adresini temsil etmektedir.
Base_Adress dinamik bellekte alan tahsis eden fonksiyonların döndürdüğü adresi temsil etmektedir.
Memory_Size ise dizinin hafızada kapladığı alanı temsil etmektedir.
Element_Size ise sizeof(veri_tipi) ile bulduğumuz değerdir.
Col_Size ise dizideki kolon sayını temsil eder.
Row_Size ise dizideki satır sayısını temsil eder.
Depth_Size ise kolon ve satır ikilisinden kaç adet olacağını temsil eder.
Formülleri bilmek hoştur amma, uygulayabilmek başkadır başka diyerek formülü, yine pointer kullanımının mümkün olduğunu bildiğim dillerde kabaca denemeye çalıştım.
Formüller aynı şekilde, farklı sözdizimlerinde(syntax) kodlanmıştır.
2 Boyutlu Dinamik Array implementasyonu (C++)
/*
Author : isocan
Purpose : How to implement dimensional dynamic array using pointers.
DateTime : 17.11.2019
Write Great Code: Volume 1: Understanding the Machine
Composite Data Types and Memory Objects
Type variable[Col_Size][Row_Size]
Element_Adress = Base_Adress + (Col_Index * Row_Size + Row_Index) * Element_Size
*/
#include <cstdint>
#include <string>
#include <stdexcept>
#include <sstream>
#include <iostream>
template <class Type>
class DimensionalArray{
private:
const std::string IndexOutOfRangeException = "IndexOutOfRangeException at ";
Type* fBaseAdress;
int32_t fColCount;
int32_t fRowCount;
int32_t fMemorySize;
private:
std::string ToString(int32_t value){
std::string outString;
std::stringstream ss;
ss << value;
outString = ss.str();
return outString;
}
std::string GetMessage(std::string indexName,int32_t index){
return std::string(IndexOutOfRangeException + indexName + "["+ ToString(index)+"]");
}
void RangeCheck(int32_t colIndex, int32_t rowIndex){
if ((colIndex < 0) || (colIndex > fColCount - 1))
throw std::out_of_range(GetMessage("colIndex",colIndex).c_str());
if ((rowIndex < 0) || (rowIndex > fRowCount - 1))
throw std::out_of_range(GetMessage("rowIndex",rowIndex).c_str());
}
int32_t Offset(int32_t colIndex, int32_t rowIndex){
RangeCheck(colIndex,rowIndex);
return (colIndex * fRowCount + rowIndex) * sizeof(Type);
}
Type* CalculateElementAdress(int32_t colIndex, int32_t rowIndex){
return fBaseAdress + Offset(colIndex,rowIndex);
}
void CalculateMemorySize(){
fMemorySize = sizeof(Type) * (fColCount * fRowCount);
}
void SetColAndRowCount(int32_t colCount,int32_t rowCount){
fColCount = colCount;
fRowCount = rowCount;
}
void MemoryAllocate(){
CalculateMemorySize();
fBaseAdress = (Type*)malloc(fMemorySize);
}
void MemoryFree(){
free(fBaseAdress);
}
public:
DimensionalArray(int32_t colCount,int32_t rowCount):
fColCount(colCount),
fRowCount(rowCount){
MemoryAllocate();
}
~DimensionalArray() {
MemoryFree();
}
public:
Type GetElement(int32_t colIndex, int32_t rowIndex){
Type* elementAdress = CalculateElementAdress(colIndex,rowIndex);
return *elementAdress;
}
void SetElement(int32_t colIndex, int32_t rowIndex, Type value){
Type* elementAdress = CalculateElementAdress(colIndex,rowIndex);
*elementAdress = value;
}
void ReSize(int32_t colCount,int32_t rowCount){
MemoryFree();
SetColAndRowCount(colCount,rowCount);
fMemorySize = CalculateMemorySize();
fBaseAdress = (Type*)realloc(fBaseAdress,fMemorySize);
}
int32_t GetColCount(){
return fColCount;
}
int32_t GetRowCount(){
return fRowCount;
}
};
int main(){
try{
DimensionalArray myTwoDimensionArray(2,2); // 2 sütun, 2 satır
myTwoDimensionArray.SetElement(0,0,31); // 1. kolon, 1. satır.
myTwoDimensionArray.SetElement(1,0,32); // 2. kolon, 1. satır
myTwoDimensionArray.SetElement(0,1,33); // 1. kolon, 2. satır
myTwoDimensionArray.SetElement(1,1,34); // 2. kolon, 2. satır
/*
int32_t value_0_0 = myTwoDimensionArray.GetElement(0,0);
std::cout << "1. kolon, 1. satır Değeri: " << value_0_0 << std::endl;
int32_t value_1_0 = myTwoDimensionArray.GetElement(1,0);
std::cout << "2. kolon, 1. satır Değeri: " << value_1_0 << std::endl;
int32_t value_0_1 = myTwoDimensionArray.GetElement(0,1);
std::cout << "1. kolon, 2. satır Değeri: " << value_0_1 << std::endl;
int32_t value_1_1 = myTwoDimensionArray.GetElement(1,1);
std::cout << "2. kolon, 2. satır Değeri: " << value_1_1 << std::endl;
*/
// test
for (size_t colIndex = 0; colIndex < myTwoDimensionArray.GetColCount(); colIndex++){
for (size_t rowIndex = 0; rowIndex < myTwoDimensionArray.GetRowCount(); rowIndex++){
int32_t value = myTwoDimensionArray.GetElement(colIndex,rowIndex);
std::cout << "["<< colIndex << "," << rowIndex <<"]" << value << std::endl;
}
}
}
catch(const std::exception& e){
std::cerr << e.what() << '\n';
}
system("pause");
return EXIT_SUCCESS;
}
/*
Author : isocan
Purpose : How to implement Three-dimensional dynamic array using pointers.
DateTime : 21.11.2019
Write Great Code: Volume 1: Understanding the Machine
Composite Data Types and Memory Objects
Type variable[Depth_Size][Col_Size][Row_Size];
Element_Adress = Base_Adress + ( (Depth_Index * Col_Size + Col_Index) * Row_Size + Row_Index) * Element_Size
*/
#include <cstdint>
#include <string>
#include <stdexcept>
#include <sstream>
#include <iostream>
template <class Type>
class ThreeDimensionalArray{
private:
const std::string IndexOutOfRangeException = "IndexOutOfRangeException at ";
Type* fBaseAdress;
int32_t fColCount;
int32_t fRowCount;
int32_t fDepthSize;
int32_t fMemorySize;
private:
std::string ToString(int32_t value){
std::string outString;
std::stringstream ss;
ss << value;
outString = ss.str();
return outString;
}
std::string GetMessage(std::string indexName,int32_t index){
return std::string(IndexOutOfRangeException + indexName + "["+ ToString(index)+"]");
}
void RangeCheck(int32_t depthIndex, int32_t colIndex, int32_t rowIndex){
if ((depthIndex < 0) || (colIndex > fDepthSize - 1))
throw std::out_of_range(GetMessage("depthIndex",depthIndex).c_str());
if ((colIndex < 0) || (colIndex > fColCount - 1))
throw std::out_of_range(GetMessage("colIndex",colIndex).c_str());
if ((rowIndex < 0) || (rowIndex > fRowCount - 1))
throw std::out_of_range(GetMessage("rowIndex",rowIndex).c_str());
}
int32_t Offset(int32_t depthIndex, int32_t colIndex, int32_t rowIndex){
RangeCheck(depthIndex,colIndex,rowIndex);
return ( (depthIndex * fColCount + colIndex) * fRowCount + rowIndex) * sizeof(Type);
}
Type* CalculateElementAdress(int32_t depthIndex, int32_t colIndex, int32_t rowIndex){
return fBaseAdress + Offset(depthIndex, colIndex, rowIndex);
}
void CalculateMemorySize(){
fMemorySize = sizeof(Type) * fDepthSize * (fColCount * fRowCount);
}
void SetDepthAndColAndRowCount(int32_t depthSize,int32_t colCount,int32_t rowCount){
fDepthSize = depthSize;
fColCount = colCount;
fRowCount = rowCount;
}
void MemoryAllocate(){
CalculateMemorySize();
fBaseAdress = (Type*)malloc(fMemorySize);
}
void MemoryFree(){
free(fBaseAdress);
}
public:
ThreeDimensionalArray(int32_t depthSize,int32_t colCount,int32_t rowCount):
fDepthSize(depthSize),
fColCount(colCount),
fRowCount(rowCount){
MemoryAllocate();
}
~ThreeDimensionalArray() {
MemoryFree();
}
public:
Type GetElement(int32_t depthIndex,int32_t colIndex, int32_t rowIndex){
Type* elementAdress = CalculateElementAdress(depthIndex,colIndex,rowIndex);
return *elementAdress;
}
void SetElement(int32_t depthIndex,int32_t colIndex, int32_t rowIndex, Type value){
Type* elementAdress = CalculateElementAdress(depthIndex,colIndex,rowIndex);
*elementAdress = value;
}
void ReSize(int32_t depthSize, int32_t colCount,int32_t rowCount){
MemoryFree();
SetDepthAndColAndRowCount(depthSize,colCount,rowCount);
CalculateMemorySize();
fBaseAdress = (Type*)realloc(fBaseAdress,fMemorySize);
}
int32_t GetColCount(){
return fColCount;
}
int32_t GetRowCount(){
return fRowCount;
}
int32_t GetDepthSize(){
return fDepthSize;
}
int32_t GetMemorySize(){
return fMemorySize;
}
};
int main(){
ThreeDimensionalArray anArray(2,2,2); // 2 adet, 2 sütun, 2 satırlık tablo
// access elements ( set)
for (size_t depthIndex = 0; depthIndex < anArray.GetDepthSize(); depthIndex++)
for (size_t colIndex = 0; colIndex < anArray.GetColCount(); colIndex++)
for (size_t rowIndex = 0; rowIndex < anArray.GetRowCount(); rowIndex++)
anArray.SetElement(depthIndex,colIndex,rowIndex, depthIndex + colIndex + rowIndex);
// access elements ( get)
for (size_t depthIndex = 0; depthIndex < anArray.GetDepthSize(); depthIndex++)
for (size_t colIndex = 0; colIndex < anArray.GetColCount(); colIndex++)
for (size_t rowIndex = 0; rowIndex < anArray.GetRowCount(); rowIndex++)
std::cout << anArray.GetElement(depthIndex,colIndex,rowIndex) << std::endl;
system("pause");
return EXIT_SUCCESS;
}
{
Author : isocan
Purpose : How to implement dimensional dynamic array using pointers.
DateTime : 17.11.2019
Write Great Code: Volume 1: Understanding the Machine
Composite Data Types and Memory Objects
Type variable[Col_Size][Row_Size]
Element_Adress = Base_Adress + (Col_Index * Row_Size + Row_Index) * Element_Size
}
unit DimensionalArray;
interface
uses
Winapi.Windows,
System.Classes,
System.SysUtils;
type
TDimensionalArray = class
const IndexOutOfRangeException = 'IndexOutOfRangeException at %d';
type
PT = ^T;
strict private
FColCount: NativeInt;
FRowCount: NativeInt;
FMemorySize : NativeInt;
FBaseAdress: PT;
FPtrWrapper : TPtrWrapper;
strict private
procedure RangeCheck(AColIndex, ARowIndex: NativeInt);
function Offset(AColIndex, ARowIndex: NativeInt): NativeInt;
function GetElement(AColIndex, ARowIndex: NativeInt): T;
procedure SetElement(AColIndex, ARowIndex: NativeInt; const Value: T);
function CalculateElementAdress(AColIndex, ARowIndex: NativeInt): PT;
procedure CalculateMemorySize();
procedure SetColAndRowCount(AColCount, ARowCount: NativeInt);
procedure MemoryAllocate();
procedure MemoryFree();
public
constructor Create(AColCount, ARowCount: NativeInt);
destructor Destroy();
public
procedure ReSize(AColCount, ARowCount: NativeInt);
public
property ColCount: NativeInt read FColCount;
property RowCount: NativeInt read FRowCount;
property Element[AColIndex, ARowIndex: NativeInt]: T read GetElement write SetElement; default;
end;
implementation
{ TDimensionalArray }
constructor TDimensionalArray.Create(AColCount, ARowCount: NativeInt);
begin
SetColAndRowCount(AColCount,ARowCount);
MemoryAllocate();
inherited Create;
end;
destructor TDimensionalArray.Destroy;
begin
TMarshal.FreeMem(FPtrWrapper);
inherited Destroy;
end;
procedure TDimensionalArray.RangeCheck(AColIndex, ARowIndex: NativeInt);
begin
if (AColIndex < 0) or (AColIndex > FColCount-1 ) then
raise Exception.Create(Format(IndexOutOfRangeException,[AColIndex]));
if (ARowIndex < 0) or (ARowIndex > FRowCount-1 ) then
raise Exception.Create(Format(IndexOutOfRangeException,[ARowIndex]));
end;
function TDimensionalArray.Offset(AColIndex, ARowIndex: NativeInt)
: NativeInt;
begin
RangeCheck(AColIndex,ARowIndex);
Result := (AColIndex * FRowCount + ARowIndex) * SizeOf(T);
end;
procedure TDimensionalArray.ReSize(AColCount, ARowCount: NativeInt);
begin
MemoryFree();
SetColAndRowCount(AColCount,ARowCount);
CalculateMemorySize();
FPtrWrapper := TMarshal.ReallocMem(FPtrWrapper,FMemorySize);
FBaseAdress := FPtrWrapper.ToPointer;
end;
procedure TDimensionalArray.SetColAndRowCount(AColCount, ARowCount: NativeInt);
begin
FColCount := AColCount;
FRowCount := ARowCount;
end;
procedure TDimensionalArray.MemoryAllocate();
begin
CalculateMemorySize();
FPtrWrapper := TMarshal.AllocMem(FMemorySize);
FBaseAdress := FPtrWrapper.ToPointer;
end;
procedure TDimensionalArray.MemoryFree;
begin
TMarshal.FreeMem(FPtrWrapper);
end;
function TDimensionalArray.CalculateElementAdress(AColIndex,
ARowIndex: NativeInt): PT;
begin
Result := PT(PByte(FBaseAdress) + Offset(AColIndex, ARowIndex));
end;
procedure TDimensionalArray.CalculateMemorySize();
begin
FMemorySize := SizeOf(T) * (FColCount * FRowCount);
end;
function TDimensionalArray.GetElement(AColIndex, ARowIndex: NativeInt): T;
begin
Result := CalculateElementAdress(AColIndex, ARowIndex)^;
end;
procedure TDimensionalArray.SetElement(AColIndex, ARowIndex: NativeInt;
const Value: T);
begin
CalculateElementAdress(AColIndex, ARowIndex)^ := Value;
end;
end.
{
Author : isocan
Purpose : How to implement Three-dimensional dynamic array using pointers.
DateTime : 21.11.2019
Write Great Code: Volume 1: Understanding the Machine
Composite Data Types and Memory Objects
Type variable[Depth_Size][Col_Size][Row_Size];
Element_Adress = Base_Adress + ( (Depth_Index * Col_Size + Col_Index) * Row_Size + Row_Index) * Element_Size
}
unit ThreeDimensionalArray;
interface
uses
Winapi.Windows,
System.Classes,
System.SysUtils;
type
TThreeDimensionalArray = class
const IndexOutOfRangeException = 'IndexOutOfRangeException at %s %d';
type
PT = ^T;
strict private
FDepthSize :NativeInt;
FColCount: NativeInt;
FRowCount: NativeInt;
FMemorySize : NativeInt;
FBaseAdress: PT;
FPtrWrapper : TPtrWrapper;
strict private
function GetMessage(AIndexName:string;AIndex:NativeInt):string;
procedure RangeCheck(ADepthIndex,AColIndex, ARowIndex: NativeInt);
function Offset(ADepthIndex,AColIndex, ARowIndex: NativeInt): NativeInt;
function GetElement(ADepthIndex,AColIndex, ARowIndex: NativeInt): T;
procedure SetElement(ADepthIndex,AColIndex, ARowIndex: NativeInt; const Value: T);
function CalculateElementAdress(ADepthIndex,AColIndex, ARowIndex: NativeInt): PT;
procedure CalculateMemorySize();
procedure SetDepthAndColAndRowCount(ADepthSize,AColCount, ARowCount: NativeInt);
procedure MemoryAllocate();
procedure MemoryFree();
public
constructor Create(ADepthSize,AColCount, ARowCount: NativeInt);
destructor Destroy();
public
procedure ReSize(ADepthSize,AColCount, ARowCount: NativeInt);
public
property DepthSize: NativeInt read FDepthSize;
property ColCount: NativeInt read FColCount;
property RowCount: NativeInt read FRowCount;
property MemorySize: NativeInt read FMemorySize;
property Element[ADepthIndex,AColIndex, ARowIndex: NativeInt]: T read GetElement write SetElement; default;
end;
implementation
{ TDimensionalArray }
constructor TThreeDimensionalArray.Create(ADepthSize,AColCount, ARowCount: NativeInt);
begin
SetDepthAndColAndRowCount(ADepthSize,AColCount,ARowCount);
MemoryAllocate();
inherited Create;
end;
destructor TThreeDimensionalArray.Destroy;
begin
TMarshal.FreeMem(FPtrWrapper);
inherited Destroy;
end;
function TThreeDimensionalArray.GetMessage(AIndexName: string;
AIndex: NativeInt): string;
begin
Result := Format(IndexOutOfRangeException,[AIndexName,AIndex]);
end;
procedure TThreeDimensionalArray.RangeCheck(ADepthIndex, AColIndex,
ARowIndex: NativeInt);
begin
if (ADepthIndex < 0) or (ADepthIndex > Pred(FDepthSize) ) then
raise Exception.Create(GetMessage('ADepthIndex',ADepthIndex));
if (AColIndex < 0) or (AColIndex > Pred(FColCount) ) then
raise Exception.Create(GetMessage('AColIndex',AColIndex));
if (ARowIndex < 0) or (ARowIndex > Pred(FRowCount) ) then
raise Exception.Create(GetMessage('ARowIndex',ARowIndex));
end;
function TThreeDimensionalArray.Offset(ADepthIndex,AColIndex, ARowIndex: NativeInt)
: NativeInt;
begin
RangeCheck(ADepthIndex,AColIndex, ARowIndex);
Result := ( (ADepthIndex * FColCount + AColIndex) * FRowCount + ARowIndex) * SizeOf(T);
end;
procedure TThreeDimensionalArray.ReSize(ADepthSize,AColCount, ARowCount: NativeInt);
begin
MemoryFree();
SetDepthAndColAndRowCount(ADepthSize,AColCount,ARowCount);
CalculateMemorySize();
FPtrWrapper := TMarshal.ReallocMem(FPtrWrapper,FMemorySize);
FBaseAdress := FPtrWrapper.ToPointer;
end;
procedure TThreeDimensionalArray.SetDepthAndColAndRowCount(ADepthSize,AColCount, ARowCount: NativeInt);
begin
FDepthSize := ADepthSize;
FColCount := AColCount;
FRowCount := ARowCount;
end;
procedure TThreeDimensionalArray.MemoryAllocate();
begin
CalculateMemorySize();
FPtrWrapper := TMarshal.AllocMem(FMemorySize);
FBaseAdress := FPtrWrapper.ToPointer;
end;
procedure TThreeDimensionalArray.MemoryFree;
begin
TMarshal.FreeMem(FPtrWrapper);
end;
function TThreeDimensionalArray.CalculateElementAdress(ADepthIndex,AColIndex,
ARowIndex: NativeInt): PT;
begin
Result := PT(PByte(FBaseAdress) + Offset(ADepthIndex,AColIndex, ARowIndex));
end;
procedure TThreeDimensionalArray.CalculateMemorySize();
begin
FMemorySize := SizeOf(T) * FDepthSize * (FColCount * FRowCount);
end;
function TThreeDimensionalArray.GetElement(ADepthIndex,AColIndex, ARowIndex: NativeInt): T;
begin
Result := CalculateElementAdress(ADepthIndex,AColIndex, ARowIndex)^;
end;
procedure TThreeDimensionalArray.SetElement(ADepthIndex,AColIndex, ARowIndex: NativeInt;
const Value: T);
begin
CalculateElementAdress(ADepthIndex,AColIndex, ARowIndex)^ := Value;
end;
end.
/*
Author : isocan
Purpose : How to implement dimensional dynamic array using pointers.
DateTime : 18.11.2019
Write Great Code: Volume 1: Understanding the Machine
Composite Data Types and Memory Objects
Type variable[Col_Size][Row_Size]
Element_Adress = Base_Adress + (Col_Index * Row_Size + Row_Index) * Element_Size
https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-7.3/blittable (Unmanaged type constraint)
*/
using System;
using System.Runtime.InteropServices;
using System.Windows.Forms;
unsafe class DimensionalArray where T : unmanaged
{
private int colCount;
private int rowCount;
private int memorySize;
private IntPtr baseAdress;
public DimensionalArray(int colCount, int rowCount)
{
SetColAndRowCount(colCount, rowCount);
MemoryAllocate();
}
private int Offset(int colIndex, int rowIndex)
{
return (colIndex * rowCount + rowIndex) * Marshal.SizeOf(typeof(T));
}
private IntPtr CalculateElementAdress(int colIndex, int rowIndex)
{
IntPtr elementAdress = IntPtr.Add(baseAdress, Offset(colIndex, rowIndex));
return elementAdress;
}
private void CalculateMemorySize()
{
memorySize = Marshal.SizeOf(typeof(T)) * (colCount * rowCount);
}
private void SetColAndRowCount(int colCount, int rowCount)
{
this.colCount = colCount;
this.rowCount = rowCount;
}
private void MemoryAllocate()
{
CalculateMemorySize();
baseAdress = Marshal.AllocHGlobal(memorySize);
}
private void ReSize(int colCount, int rowCount)
{
/*
cb:IntPtr
The new size of the allocated block.
This is not a pointer; it is the byte count you are requesting, cast to type IntPtr.
If you pass a pointer, it is treated as a size.
https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.marshal.reallochglobal?view=netframework-4.8
*/
MemoryFree();
SetColAndRowCount(colCount, rowCount);
CalculateMemorySize();
baseAdress = Marshal.ReAllocHGlobal(baseAdress, (IntPtr)memorySize);
}
private void MemoryFree()
{
Marshal.FreeHGlobal(baseAdress);
}
public int ColCount { get { return colCount; } }
public int RowCount { get { return rowCount; } }
private T* GetElementAdress(int colIndex, int rowIndex)
{
void* unTypedElementAdress = CalculateElementAdress(colIndex, rowIndex).ToPointer();
T* typedElementAdress = (T*)unTypedElementAdress;
return typedElementAdress;
}
public T this[int colIndex, int rowIndex]
{
get
{
return *GetElementAdress(colIndex, rowIndex);
}
set
{
*GetElementAdress(colIndex, rowIndex) = value;
}
}
~DimensionalArray()
{
MemoryFree();
}
}
class Program
{
static void Main(string[] args)
{
DimensionalArray myTwoDimensionArray = new DimensionalArray(2, 2);
myTwoDimensionArray[0, 0] = 31;
myTwoDimensionArray[1, 0] = 32;
myTwoDimensionArray[0, 1] = 33;
myTwoDimensionArray[1, 1] = 34;
// test
for (int colIndex = 0; colIndex < myTwoDimensionArray.ColCount; colIndex++)
{
for (int rowIndex = 0; rowIndex < myTwoDimensionArray.RowCount; rowIndex++)
{
int value = myTwoDimensionArray[colIndex, rowIndex];
MessageBox.Show(value.ToString());
}
}
}
}
/*
Author : isocan
Purpose : How to implement Three-dimensional dynamic array using pointers.
DateTime : 21.11.2019
Write Great Code: Volume 1: Understanding the Machine
Composite Data Types and Memory Objects
Type variable[Depth_Size][Col_Size][Row_Size];
Element_Adress = Base_Adress + ( (Depth_Index * Col_Size + Col_Index) * Row_Size + Row_Index) * Element_Size
https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/proposals/csharp-7.3/blittable (Unmanaged type constraint)
*/
using System;
using System.Windows.Forms;
using System.Runtime.InteropServices;
unsafe class ThreeDimensionalArray where T : unmanaged
{
private const string IndexOutOfRangeException = "IndexOutOfRangeException at %s %d";
private int depthSize;
private int colCount;
private int rowCount;
private int memorySize;
private IntPtr baseAdress;
public ThreeDimensionalArray(int depthSize, int colCount, int rowCount)
{
SetDepthAndColAndRowCount(depthSize, colCount, rowCount);
MemoryAllocate();
}
private string GetMessage(string indexName, int index)
{
return string.Format(IndexOutOfRangeException, indexName, index);
}
private void RangeCheck(int depthIndex, int colIndex, int rowIndex)
{
if ((depthIndex < 0) || (colIndex > depthSize - 1))
throw new Exception(GetMessage("depthIndex", depthIndex));
if ((colIndex < 0) || (colIndex > colCount - 1))
throw new Exception(GetMessage("colIndex", colIndex));
if ((rowIndex < 0) || (rowIndex > rowCount - 1))
throw new Exception(GetMessage("rowIndex", rowIndex));
}
private int Offset(int depthIndex, int colIndex, int rowIndex)
{
RangeCheck(depthIndex, colIndex, rowIndex);
return ((depthIndex * colCount + colIndex) * rowCount + rowIndex) * Marshal.SizeOf(typeof(T));
}
private IntPtr CalculateElementAdress(int depthIndex, int colIndex, int rowIndex)
{
IntPtr elementAdress = IntPtr.Add(baseAdress, Offset(depthIndex, colIndex, rowIndex));
return elementAdress;
}
private void CalculateMemorySize()
{
memorySize = Marshal.SizeOf(typeof(T)) * this.depthSize * (this.colCount * this.rowCount);
}
private void SetDepthAndColAndRowCount(int depthSize, int colCount, int rowCount)
{
this.depthSize = depthSize;
this.colCount = colCount;
this.rowCount = rowCount;
}
private void MemoryAllocate()
{
CalculateMemorySize();
baseAdress = Marshal.AllocHGlobal(memorySize);
}
private void ReSize(int depthSize, int colCount, int rowCount)
{
/*
cb:IntPtr
The new size of the allocated block.
This is not a pointer; it is the byte count you are requesting, cast to type IntPtr.
If you pass a pointer, it is treated as a size.
https://docs.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.marshal.reallochglobal?view=netframework-4.8
*/
MemoryFree();
SetDepthAndColAndRowCount(depthSize, colCount, rowCount);
CalculateMemorySize();
baseAdress = Marshal.ReAllocHGlobal(baseAdress, (IntPtr)memorySize);
}
private void MemoryFree()
{
Marshal.FreeHGlobal(baseAdress);
}
public int DepthSize { get { return depthSize; } }
public int ColCount { get { return colCount; } }
public int RowCount { get { return rowCount; } }
public int MemorySize { get { return memorySize; } }
private T* GetElementAdress(int depthIndex, int colIndex, int rowIndex)
{
void* unTypedElementAdress = CalculateElementAdress(depthIndex, colIndex, rowIndex).ToPointer();
T* typedElementAdress = (T*)unTypedElementAdress;
return typedElementAdress;
}
public T this[int depthIndex, int colIndex, int rowIndex]
{
get
{
return *GetElementAdress(depthIndex, colIndex, rowIndex);
}
set
{
*GetElementAdress(depthIndex, colIndex, rowIndex) = value;
}
}
~ThreeDimensionalArray()
{
MemoryFree();
}
}
class Program
{
static void Main(string[] args)
{
ThreeDimensionalArray anArray = new ThreeDimensionalArray(2, 2, 2);
//anArray.MemorySize;
// set values
for (int depthIndex = 0; depthIndex < anArray.DepthSize; depthIndex++)
for (int colIndex = 0; colIndex < anArray.ColCount; colIndex++)
for (int rowIndex = 0; rowIndex < anArray.RowCount; rowIndex++)
anArray[depthIndex, colIndex, rowIndex] = depthIndex + colIndex + rowIndex;
// access elements
for (int depthIndex = 0; depthIndex < anArray.DepthSize; depthIndex++)
{
for (int colIndex = 0; colIndex < anArray.ColCount; colIndex++)
{
for (int rowIndex = 0; rowIndex < anArray.RowCount; rowIndex++)
{
int value = anArray[depthIndex, colIndex, rowIndex];
}
}
}
}
}
Dynamic Array Implementation[Dimensional]
Dynamic Array Implementation[Three-Dimensional]
