C++ General: How to declare and use two-dimensional arrays?

[Andreas Masur]

Q: How can I define a dynamic two-dimensional array?

A: The following class shows one way of encapsulating a two-dimensional array:

template <class T>
class dynamic_2d_array
{
public:
  dynamic_2d_array(int row, int col) : m_row(row),
                                       m_col(col),
                                       m_data((row != 0 && col != 0) ? new T[row * col] : NULL){}

  dynamic_2d_array(const dynamic_2d_array& src) : m_row(src.m_row),
                                                  m_col(src.m_col),
                                                  m_data((src.m_row != 0 && src.m_col != 0) ? new T[src.m_row * src.m_col] : NULL)
  {
    for(int r = 0;r < m_row; ++r)
      for(int c = 0; c < m_col; ++c)
        (*this)[r][c] = src[r][c];
  }

  ~dynamic_2d_array()
  {
    if(m_data)
      delete []m_data;
  }
  
  inline T* operator[](int i) { return (m_data + (m_col * i)); }

  inline T const*const operator[](int i) const {return (m_data + (m_col * i)); }


private:
  dynamic_2d_array& operator=(const dynamic_2d_array&);
  const int m_row;
  const int m_col;
  T* m_data; 
};

A different approach using the STL 'vector' class is shown in the following FAQ...


FAQ contributed by: [Axter]

[NMTop40]

A: Here is another alternative approach. This uses a non-standard notation but is simple to use. I will call the class matrix.

template <typename T>
class Matrix
{
private:
   size_t m_nRows;
   size_t m_nCols;
   std::vector< T > m_vect;

public:
   Matrix( size_t nRows=0. size_t nCols=0, const T& t= T() )
    : m_nRows( nRows ), m_nCols (nCols), m_vect( nRows * nCols, t )
   {
   }

   size_t rows() const { return m_nRows; }
   size_t cols() const { return m_nCols; }

   T& operator()( size_t row, size_t col )
   {
        assert( row < m_nRows && col < m_nCols );
        return m_vect[ row * m_nCols + col ];
   }

   const T& operator()( size_t row, size_t col ) const
   {
        assert( row < m_nRows && col < m_nCols );
        return m_vect[ row * m_nCols + col ];
   }
        
   T* getRow( size_t  row )
   {
         assert( row <= m_nRows ); // we allow one past the end
                                             // this permits certain algorithms

         return &m_vect[ row * m_nCols ];
   }

   const T* getRow( size_t row ) const
   {
         assert( row <= m_nRows ); // see comment above
         return &m_vect[ row * m_nCols ];
   }
 
   T* operator[]( size_t  row ) // same as getRow
   {
       return getRow( row );
    }

   const T* operator[]( size_t row ) const
   {
        return getRow( row );
    }
   
   class const_row_iterator
   {
     private:
          const Matrix * m_pMatrix;
          size_t m_nRow;
    
     public:
          const_row_iterator( const Matrix *pMatrix=0, size_t nRow = 0 )
             : m_pMatrix (pMatrix), m_nRow( nRow )
          {
          }

       bool operator!=( const const_row_iterator & rhs )const
       {
            return (m_row != rhs.m_row) || (m_pMatrix != rhs.m_pMatrix);
       {

       const T* operator*() const
       {
            return m_pMatrix->getRow( m_nRow );
       }

       const_row_iterator& operator++()
       {
          ++m_nRow;
          return *this;
      }

      const_row_iterator operator++( int )
      {
          const_row_iterator itCopy( *this );
          ++m_nRow;
         return itCopy;
     }
  }; // end of const_row_iterator class

   const_row_iterator begin() const
    {
       return const_row_iterator( this, 0 );
    }

    const_row_iterator end() const
    {
        return const_row_iterator( this, m_nRows );
    }
};

That will give you reasonable functionality. You can do more with it (add a non-const iterator, give iterator more than FwdIterator traits).

Note: For matrices of numerical types, it may be better to use valarray instead of vector. Then a row could be returned as slicearray. I have never actually implemented one this way though.