Very Fast Dyanmic Two Dimensional Array Class for Critical Review

[Peter Olcott]

//
// Array2D.h 2005-11-27 5:50 AM
//
#define UINT unsigned int
//
//
//
class ArrayType2D {
private:
int Width;
int Height;
int Size;
UINT* Array;
bool Allocated;
void Copy(ArrayType2 D& Array2);
public:
ArrayType2D();
ArrayType2D(Arr ayType2D& Array2) { Copy(Array2); };
~ArrayType2D() { if (Allocated) delete [] Array; };
UINT& operator()(cons t UINT ROW, const UINT COL) { return Array[ROW * Width + COL]; }
ArrayType2D& operator=(Array Type2D& Array2) { Copy(Array2); return *this; };
UINT* operator&() { return Array; };
const int width() { return Width; };
const int height() { return Height; };
void Allocate(int Height, int Width);
};

void ArrayType2D::Co py(ArrayType2D& Array2) {
if (this->Allocated)
delete [] Array;
this->Width = Array2.Width;
this->Height = Array2.Height;
this->Size = Array2.Size;
this->Array = new UINT [Size];
for (int N = 0; N < Size; N++)
Array[N] = Array2.Array[N];
this->Allocated = true;
}

ArrayType2D::Ar rayType2D() {
Width = 0;
Height = 0;
Size = 0;
Array = NULL;
Allocated = false;
}

inline void ArrayType2D::Al locate(int Height, int Width) {
if (Allocated)
delete [] Array;
this->Width = Width;
this->Height = Height;
this->Size = Width * Height;
this->Array = new UINT [Size];
this->Allocated = true;
}

[Peter Olcott]

//
// Array2D.h 2005-11-27 5:50 AM
//
#define UINT unsigned int
//
//
//
class ArrayType2D {
private:
int Width;
int Height;
int Size;
UINT* Array;
bool Allocated;
void Copy(ArrayType2 D& Array2);
public:
ArrayType2D();
ArrayType2D(Arr ayType2D& Array2) { Copy(Array2); };
~ArrayType2D() { if (Allocated) delete [] Array; };
UINT& operator()(cons t UINT ROW, const UINT COL) { return Array[ROW * Width + COL]; }
ArrayType2D& operator=(Array Type2D& Array2) { Copy(Array2); return *this; };
UINT* operator&() { return Array; };
const int width() { return Width; };
const int height() { return Height; };
void Allocate(int Height, int Width);
};

void ArrayType2D::Co py(ArrayType2D& Array2) {
if (this->Allocated)
delete [] Array;
this->Width = Array2.Width;
this->Height = Array2.Height;
this->Size = Array2.Size;
this->Array = new UINT [Size];
for (int N = 0; N < Size; N++)
Array[N] = Array2.Array[N];
this->Allocated = true;
}

ArrayType2D::Ar rayType2D() {
Width = 0;
Height = 0;
Size = 0;
Array = NULL;
Allocated = false;
}

inline void ArrayType2D::Al locate(int Height, int Width) {
if (Allocated)
delete [] Array;
this->Width = Width;
this->Height = Height;
this->Size = Width * Height;
this->Array = new UINT [Size];
this->Allocated = true;
}

[Peter Olcott]

//
// Array2D.h 2005-11-27 5:50 AM
//
#define UINT unsigned int

class ArrayType2D {
private:
int Width;
int Height;
int Size;
UINT* Array;
bool Allocated;
void Copy(ArrayType2 D& Array2);
public:
ArrayType2D();
ArrayType2D(Arr ayType2D& Array2) { Copy(Array2); };
~ArrayType2D() { if (Allocated) delete [] Array; };
UINT& operator()(cons t UINT ROW, const UINT COL) { return Array[ROW * Width + COL]; }
ArrayType2D& operator=(Array Type2D& Array2) { Copy(Array2); return *this; };
UINT* operator&() { return Array; };
const int width() { return Width; };
const int height() { return Height; };
void Allocate(int Height, int Width);
};

void ArrayType2D::Co py(ArrayType2D& Array2) {
if (this->Allocated)
delete [] Array;
this->Width = Array2.Width;
this->Height = Array2.Height;
this->Size = Array2.Size;
this->Array = new UINT [Size];
for (int N = 0; N < Size; N++)
Array[N] = Array2.Array[N];
this->Allocated = true;
}

ArrayType2D::Ar rayType2D() {
Width = 0;
Height = 0;
Size = 0;
Array = NULL;
Allocated = false;
}

inline void ArrayType2D::Al locate(int Height, int Width) {
if (Allocated)
delete [] Array;
this->Width = Width;
this->Height = Height;
this->Size = Width * Height;
this->Array = new UINT [Size];
this->Allocated = true;
}

[Neelesh Bodas]

Peter Olcott wrote:

//
// Array2D.h 2005-11-27 5:50 AM
//

I actually couldn't get what is "fast" and what is "dynamic" with this
Array class. Its not even polymorphic.
You could get much more with, say vectors.

Or am I missing something out here?

[Peter Olcott]

"Neelesh Bodas" <ne***********@ gmail.com> wrote in message news:11******** *************@g 47g2000cwa.goog legroups.com...

Peter Olcott wrote:

//
// Array2D.h 2005-11-27 5:50 AM
//

I actually couldn't get what is "fast" and what is "dynamic" with this
Array class. Its not even polymorphic.
You could get much more with, say vectors.

Or am I missing something out here?

I have not yet transformed it into the syntax of templates, so it only
does unsigned integers at the moment. I will make this conversion
some time soon. The memory allocated to this array is dynamically
allocated at run-time as opposed to statically allocated at compile-time.
Every other dynamically allocated array is either restricted to single
dimensional access, or allocates each row separately, making it much
slower. When I benchmarked this latter design it was fifty-fold slower
than my design.

[John Harrison]

Peter Olcott wrote:

"Neelesh Bodas" <ne***********@ gmail.com> wrote in message news:11******** *************@g 47g2000cwa.goog legroups.com...

Peter Olcott wrote:

//
// Array2D.h 2005-11-27 5:50 AM
//

I actually couldn't get what is "fast" and what is "dynamic" with this
Array class. Its not even polymorphic.
You could get much more with, say vectors.

Or am I missing something out here?

I have not yet transformed it into the syntax of templates, so it only
does unsigned integers at the moment. I will make this conversion
some time soon. The memory allocated to this array is dynamically
allocated at run-time as opposed to statically allocated at compile-time.
Every other dynamically allocated array is either restricted to single
dimensional access, or allocates each row separately, making it much
slower. When I benchmarked this latter design it was fifty-fold slower
than my design.

Allocated is unnecessary.

~ArrayType2D() { delete [] Array; };

works correctly even if Array is NULL.

john

[Peter Olcott]

"John Harrison" <jo************ *@hotmail.com> wrote in message news:L2******** *********@newsf e6-win.ntli.net...

Peter Olcott wrote:

"Neelesh Bodas" <ne***********@ gmail.com> wrote in message news:11******** *************@g 47g2000cwa.goog legroups.com...

Peter Olcott wrote:

//
// Array2D.h 2005-11-27 5:50 AM
//

I actually couldn't get what is "fast" and what is "dynamic" with this
Array class. Its not even polymorphic.
You could get much more with, say vectors.

Or am I missing something out here?

I have not yet transformed it into the syntax of templates, so it only
does unsigned integers at the moment. I will make this conversion
some time soon. The memory allocated to this array is dynamically
allocated at run-time as opposed to statically allocated at compile-time.
Every other dynamically allocated array is either restricted to single
dimensional access, or allocates each row separately, making it much
slower. When I benchmarked this latter design it was fifty-fold slower
than my design.

Allocated is unnecessary.

~ArrayType2D() { delete [] Array; };

works correctly even if Array is NULL.

john

It turns out that my whole class in unnecessary. Gianni Mariani's
original posting on the other thread is already perfect in every way.
news:q4******** *************** *******@speakea sy.net...

[Peter Olcott]

"John Harrison" <jo************ *@hotmail.com> wrote in message news:L2******** *********@newsf e6-win.ntli.net...

Peter Olcott wrote:

"Neelesh Bodas" <ne***********@ gmail.com> wrote in message news:11******** *************@g 47g2000cwa.goog legroups.com...

Peter Olcott wrote:

//
// Array2D.h 2005-11-27 5:50 AM
//

I actually couldn't get what is "fast" and what is "dynamic" with this
Array class. Its not even polymorphic.
You could get much more with, say vectors.

Or am I missing something out here?

I have not yet transformed it into the syntax of templates, so it only
does unsigned integers at the moment. I will make this conversion
some time soon. The memory allocated to this array is dynamically
allocated at run-time as opposed to statically allocated at compile-time.
Every other dynamically allocated array is either restricted to single
dimensional access, or allocates each row separately, making it much
slower. When I benchmarked this latter design it was fifty-fold slower
than my design.

Allocated is unnecessary.

It turns out that the whole class is unnecessary, Gianni Mariani's
earlier posting is already perfect in every way.

"Gianni Mariani" <gi*******@mari ani.ws> wrote in message
news:q4******** *************** *******@speakea sy.net...


~ArrayType2D() { delete [] Array; };

works correctly even if Array is NULL.

john

[Karl Heinz Buchegger]

> Peter Olcott wrote:

As usual:
You created something that you say is very fast.
But it has problems in functionality (aka: bugs).

You might analyze the problems of Copy. Especially if it is called
from the copy constructor. (Start with asking: What does Allocated
tell me, what the pointer 'Array' doesn't tell me, if used and initialized
correctly)

--
Karl Heinz Buchegger
kb******@gascad .at

[Axter]

Peter Olcott wrote:

//
// Array2D.h 2005-11-27 5:50 AM
//
#define UINT unsigned int
//
//
//
class ArrayType2D {
private:
int Width;
int Height;
int Size;
UINT* Array;
bool Allocated;
void Copy(ArrayType2 D& Array2);
public:
ArrayType2D();
ArrayType2D(Arr ayType2D& Array2) { Copy(Array2); };
~ArrayType2D() { if (Allocated) delete [] Array; };
UINT& operator()(cons t UINT ROW, const UINT COL) { return Array[ROW * Width + COL]; }
ArrayType2D& operator=(Array Type2D& Array2) { Copy(Array2); return *this; };
UINT* operator&() { return Array; };
const int width() { return Width; };
const int height() { return Height; };
void Allocate(int Height, int Width);
};

void ArrayType2D::Co py(ArrayType2D& Array2) {
if (this->Allocated)
delete [] Array;
this->Width = Array2.Width;
this->Height = Array2.Height;
this->Size = Array2.Size;
this->Array = new UINT [Size];
for (int N = 0; N < Size; N++)
Array[N] = Array2.Array[N];
this->Allocated = true;
}

ArrayType2D::Ar rayType2D() {
Width = 0;
Height = 0;
Size = 0;
Array = NULL;
Allocated = false;
}

inline void ArrayType2D::Al locate(int Height, int Width) {
if (Allocated)
delete [] Array;
this->Width = Width;
this->Height = Height;
this->Size = Width * Height;
this->Array = new UINT [Size];
this->Allocated = true;
}

Try comparing the above class to using std::vector<std ::vector<T> >
You'll be surprise at the results. On some implementations the vector
version is faster then above class.
Also check out the following class:
http://code.axter.com/dynamic_2d_array.h

Also, I recommend using [][] access method over operator().
I don't recommend following the FAQ recommendation on this matter.