d_matrix.h

#ifndef MATRIX_CLASS
#define MATRIX_CLASS

#include <iostream>
#include <vector>

#include "d_except.h"

using namespace std;

template <typename T>
class matrix
{
  public:
   matrix(int numRows = 1, int numCols = 1, const T& initVal = T());
   // constructor.
   // Postcondition: create array having numRows x numCols elements
   // all of whose elements have value initVal

   vector<T>& operator[] (int i);
   // index operator.
   // Precondition: 0 <= i < nRows. a violation of this
   // precondition throws the indexRangeError exception.
   // Postcondition: if the operator is used on the left-hand
   // side of an assignment statement, an element of row i 
   // is changed

   const vector<T>& operator[](int i) const;
   // version for constant objects

   int rows() const;
   // return number of rows
   int cols() const;
   // return number of columns

   void resize(int numRows, int numCols);
   // modify the matrix size.
   // Postcondition: the matrix has size numRows x numCols.
   // any new elements are filled with the default value of type T

  private:
   int nRows, nCols;
   // number of rows and columns

   vector<vector<T> > mat;
   // matrix is implemented as nRows vectors (rows),
   // each having nCols elements (columns)
};

template <typename T>
matrix<T>::matrix(int numRows, int numCols, const T& initVal):
	nRows(numRows), nCols(numCols),
	mat(numRows, vector<T>(numCols,initVal))
{}

// non-constant version. provides general access to matrix
// elements
template <typename T>
vector<T>& matrix<T>::operator[] (int i)
{
   if (i < 0 || i >= nRows)
      throw indexRangeError(
	 "matrix: invalid row index", i, nRows);

   return mat[i];
}

// constant version.  can be used with a constant object.
// does not allow modification of a matrix element
template <typename T>
const vector<T>& matrix<T>::operator[] (int i) const
{
   if (i < 0 || i >= nRows)
      throw indexRangeError(
	 "matrix: invalid row index", i, nRows);

   return mat[i];
}

template <typename T>
int matrix<T>::rows() const
{
   return nRows;
}

template <typename T>
int matrix<T>::cols() const
{
   return nCols;
}

template <typename T>
void matrix<T>::resize(int numRows, int numCols)
{
   int i;
   
   // handle case of no size change with a return
   if (numRows == nRows && numCols == nCols)
      return;

   // assign the new matrix size
   nRows = numRows;
   nCols = numCols;

   // resize to nRows rows
   mat.resize(nRows);

   // resize each row to have nCols columns
   for (i=0; i < nRows; i++)
      mat[i].resize(nCols);
}

#endif	// MATRIX_CLASS