Re: multi-dimentional arrays

To add to what others wrote, you may want to use a simple C++ template class
I developed to manage 2D arrays (internally represented as 1D array).

http://www.geocities.com/giovanni.dicanio/vc/Array2D.zip

The above link contains a VS2008 project to show how to use the array.

Basically, you can write code like this:

  // rows and columns are integers...
  CArray2D< string > data( rows, columns );

  // Fill data:
  data.SetAt( 0, 0, "Bob" ); // row 0, column 0
  data.SetAt( 0, 1, "False" ); // row 0, column 1
   ...

You can also use chained calls like this:

   data.SetAt( ... ).SetAt( ... ) ... .SetAt( ... );

This is the file Array2D.h (the header file where the Array2D template class
is defined):

<file name="Array2D.h">
//////////////////////////////////////////////////////////////////////////
// Array2D.h
// A template class representing a 2D array.
//
// By Giovanni Dicanio <gdicanio@email.it>
// Last update: 2008, August 20th
//////////////////////////////////////////////////////////////////////////

template <typename T>
class Array2D
{
public:

    //
    // CONSTRUCTION
    //

    // Creates an empty array
    Array2D()
        : m_rows( 0 ), m_columns( 0 )
    {

    }

    // Creates an array with specified size
    explicit Array2D( int rows, int columns )
        : m_rows( 0 ), m_columns( 0 )
    {
        Resize( rows, columns );
    }

    //
    // PROPERTIES
    //

    // Returns number of rows
    int Rows() const
    {
        return m_rows;
    }

    // Returns number of columns
    int Columns() const
    {
        return m_columns;
    }

    // Is the array empty (i.e. 0 rows and 0 columns) ?
    bool IsEmpty() const
    {
        if ( m_rows == 0 && m_columns == 0 )
        {
            return true;
        }
        else
        {
            // Can't have 0 rows and >= 0 columns, or vice versa
            ASSERT( m_rows > 0 );
            ASSERT( m_columns > 0 );

            return false;
        }
    }

    //
    // OPERATIONS
    //

    // Clears the array (i.e. makes it empty)
    Array2D & Clear()
    {
        m_rows = 0;
        m_columns = 0;
        m_data.clear();

        return *this;
    }

    // Changes array size
    Array2D & Resize( int rows, int columns )
    {
        ASSERT( rows > 0 );
        ASSERT( columns > 0 );

        m_data.resize( rows * columns );
        m_rows = rows;
        m_columns = columns;

        return *this;
    }

    // Returns element at specified position
    // (row and column are 0-based)
    const T & GetAt( int row, int column ) const
    {
        ASSERT( ! IsEmpty() );
        ASSERT( IsValidIndex( row, column ) );

        return m_data[ Map2DIndexIn1D( row, column ) ];
    }

    // Changes element at specified position
    // (row and column are 0-based).
    // It is possible to do chained calls
    // e.g. myArray.SetAt(...).SetAt(...) ... .SetAt(...);
    Array2D & SetAt( int row, int column, const T & value )
    {
        ASSERT( ! IsEmpty() );
        ASSERT( IsValidIndex( row, column ) );

        m_data[ Map2DIndexIn1D( row, column ) ] = value;

        return *this;
    }

    //
    // IMPLEMENTATION
    //
private:

    //
    // DATA MEMBERS
    //

    std::vector< T > m_data; // Stores array data, in 1D array
    int m_rows; // Number of rows
    int m_columns; // Number of columns

    //
    // HELPER METHODS
    //

    // Checks if input position (row, column) is valid.
    // Row and column are 0-based, like in raw C/C++ arrays.
    bool IsValidIndex( int row, int column ) const
    {
        if ( row >= 0 && row < m_rows &&
             column >= 0 && column < m_columns )
        {
            // Valid index
            return true;
        }
        else
        {
            // Invalid index
            return false;
        }
    }

    // This class stores "virtual 2D" array data as internal 1D array.
    // This helper method converts a 2D index (row, column)
    // in a 1D index to be used for the internal array.
    int Map2DIndexIn1D( int row, int column ) const
    {
        ASSERT( IsValidIndex( row, column ) );

        // 2D ==> 1D conversion
        //
        // 2D array is stored row-wise, i.e.
        // row0, row1, ..., row(N-1)
        return (row * m_columns) + column;
    }
};

</file>

HTH,
Giovanni

"Ricardo Furtado" <RicardoFurtado@discussions.microsoft.com> ha scritto nel
messaggio news:92F174E4-CBEF-42DC-8B3C-A245F909D9BD@microsoft.com...