Re: Another question about multidimentional arrays

"Ron Francis" <ronfrancis@adam.com.au> ha scritto nel messaggio
news:uPSIMjYxIHA.4488@TK2MSFTNGP04.phx.gbl...


Hi Ron,

I think that there is no important speed gain (however, you may check the
code generated by the compiler...).

I read also other posts of yours about this topic, and IMHO it is better
to define a robust C++ class to manage multi-dimensional arrays than using
the "raw" C-like version.

For example, if you design and implement a C++ class to store
multi-dimensional arrays, you can store data members with array row and
column count.

You can also implement bounds checking for array index (indexes that go
out of bounds are a major cause of security problems via buffer
overruns...).

You can store your 2D array using a 1D array inside your class (e.g. using
STL classes like std::vector or std::valarray), storing the original array
row-wise or column-wise.
Then you can implement class methods to access array elements, converting
a 2D index (row, column) into a 1D index in the private data member 1D
array.

You may consider the following simple C++ code to be useful:

<code>

#include <atlbase.h> // for ATLASSERT
#include <iostream> // C++ cout
#include <vector> // STL vector container

//////////////////////////////////////////////////////////////////////////
//
// A 2D array
//
//////////////////////////////////////////////////////////////////////////
template <typename T>
class Matrix
{
public:

   // Create matrix with given dimensions
   explicit Matrix( int rowCount, int columnCount )
       : data( rowCount * columnCount ),
         rows( rowCount ),
         columns( columnCount )
   {
       // ... may check input parameters
       ATLASSERT( rowCount > 0 );
       ATLASSERT( columnCount > 0 );
   }

   // Number of rows
   int Rows() const
   {
       return rows;
   }

   // Number of columns
   int Columns() const
   {
       return columns;
   }

   // Access array elements (read-only)
   const T & At( int row, int column ) const
   {
       return data.at( Get1DIndex(row, column) );
   }

   // Access array elements
   T & At( int row, int column )
   {
       return data.at( Get1DIndex(row, column) );
   }

   // *** IMPLEMENTATION ***
private:

   // Store 2D matrix data in 1D vector
   // Or use std::valarray...
   std::vector< T > data;

   // Number of rows
   int rows;

   // Number of columns
   int columns;

   // Check that given index is valid
   bool IsValidIndex( int row, int column ) const
   {
       ATLASSERT( rows >= 0 );
       ATLASSERT( columns >= 0 );

       if ( row < 0 || row >= rows )
           return false;

       if ( column < 0 || column >= columns )
           return false;

       return true;
   }

   // Convert 2D index into 1D
   int Get1DIndex( int row, int column ) const
   {
       ATLASSERT( IsValidIndex(row, column) );

       // 2D data are stored in 1D array row-wise
       return ( column + (row * columns) );
   }
};

//////////////////////////////////////////////////////////////////////////

//
// Print matrix to cout
//
template <typename T>
void Print( const Matrix<T> & m )
{
   for ( int r = 0; r < m.Rows(); r++ )
   {
       for ( int c = 0; c < m.Columns(); c++ )
       {
           std::cout << m.At(r, c) << " ";
       }

       std::cout << std::endl;
   }
   std::cout << std::endl;
}

// *** TEST ***
int main()
{
   Matrix<double> A( 3, 2 );

   Print( A );

   A.At(0,0) = 2;
   A.At(1,1) = 3;
   A.At(2,0) = 1;
   A.At(2,1) = -1;
   // A.At(3,2) = 2; <<-- test bounds checking (assert fails)
   Print(A);

   system("PAUSE");
   return 0;
}

</code>

And you may also consider /ad hoc/ C++ libraries for (fast) matrix
computation (like Blitz++).

HTH,
Giovanni