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