Array of two dimension

[RePrasad]

I am new to the C++ programming. I would like to create a two dimensional array to store values of count X 240. where count is number of particles in a system - shall know only when it is counted.

Pl. help

[hoxsiew]

See:

http://www.codeproject.com/KB/cpp/arrayDinamic.aspx

[Joeman]

Originally Posted by hoxsiew

See:

http://www.codeproject.com/KB/cpp/arrayDinamic.aspx

That code is incorrect. A simple look at it would tell that it leaks memory

just a quick fix would be

#include <iostream>
 
template <typename T>
T **AllocateDynamicArray( int nRows, int nCols)
{
      T **dynamicArray;
      dynamicArray = new T*[nRows];
      for( int i = 0 ; i < nRows ; i++ )
      dynamicArray[i] = new T [nCols];
      return dynamicArray;
}
 
template <typename T>
void FreeDynamicArray(T** dArray, int nRows)
{
      for( int i = 0 ; i < nRows ; i++ ) delete [] dArray[i];
      delete [] dArray;
}
 
using namespace std;
 
int main()
{
      int **my2dArr = AllocateDynamicArray<int>(4,4);
      my2dArr[0][0]=5;
      my2dArr[2][2]=8;
      cout << my2dArr[0][0] << my2dArr[0][1] << endl;
      cout << my2dArr[1][1] <<  my2dArr[2][2]<< endl;
      FreeDynamicArray<int>(my2dArr, 4);
      return 0;
}

Blue is corrected
Perhaps someone should email the author with a fix ... I am not

[Paul McKenzie]

Originally Posted by Joeman

That code is incorrect. A simple look at it would tell that it leaks memory

Not only that, if the array size doesn't change after the array is allocated, the creation code calls the allocator (nRows*nCols + 1) times. If the array is 100x100, the allocator is called 10001 times.

You really only need to call the allocator twice, regardless of the size of the array. Here is a better version:

#include <iostream>
 
template <typename T>
T **AllocateDynamicArray( int nRows, int nCols)
{
      T **dynamicArray;
      dynamicArray = new T*[nRows];

      T* pool = new T[nRows*nCols];

      for( int i = 0 ; i < nRows ; i++, pool += nCols )
              dynamicArray[i] = pool;

      return dynamicArray;
}
 
template <typename T>
void FreeDynamicArray(T** dArray)
{
    delete [] dArray[0];
    delete [] dArray;
}

Much more efficient with none of the fragmentation that could occur if the array is large.

Regards,

Paul McKenzie