#pragma option -w-inl -w-pch
#include 
#include     using namespace std;    #define _NO_THROW             //  throw ()
#define _THROW_MATRIX_ERROR   //  throw (matrix_error)    class matrix_error
{
   public:
         matrix_error (const string& what_arg) {cout<
class matrix
{
        private:
    vector > _m;
          size_t Row,Col;
        public:
   // Constructors
         matrix (const matrix& m);
   matrix (size_t row = 6, size_t col = 6 );       // Assignment operators
   matrix& operator = (const matrix& m) _NO_THROW;
   
   // Value extraction method
   size_t RowNo() const { return Row; }
   size_t ColNo() const { return Col; }
   
   // Subscript operator
   T& operator () (size_t row, size_t col) _THROW_MATRIX_ERROR;
   T  operator () (size_t row, size_t col) const _THROW_MATRIX_ERROR;       // Unary operators
   matrix operator   () _NO_THROW { return *this; }
   matrix operator - () _NO_THROW;
   
   // Combined assignment - calculation operators
     matrix  operator * (const matrix& m) _THROW_MATRIX_ERROR; //dot multiple 
     matrix  operator * (const T& c) _NO_THROW;
     friend matrix operator * (const T& c,const matrix& m) _NO_THROW;
 };
 
//=========Methd define=======================================    //constructor
template 
inline matrix::matrix (size_t row, size_t col)
{ Row=row;
  Col=col;
   _m=*new vector > (row,vector(col,0));
 
}     // copy constructor
template 
inline matrix::matrix (const matrix& m)
{
    Row=m.Row;
    Col=m.Col;
    _m=m._m;
    
}    // assignment operator
template 
inline matrix& matrix::operator = (const matrix& m) _NO_THROW
{
    Row=m.Row;
    Col=m.Col;
    _m = m._m;
    return *this;
}    // subscript operator to get/set individual elements
template 
inline T& matrix::operator () (size_t row, size_t col) _THROW_MATRIX_ERROR
{
   if (row >= Row || col >= Col)
      REPORT_ERROR( "matrix::operator(): Index out of range!");
   return _m[row][col];
}    // subscript operator to get/set individual elements
template 
inline T matrix::operator () (size_t row, size_t col) const _THROW_MATRIX_ERROR
{  
   if (row >= Row || col >= Col)
      REPORT_ERROR( "matrix::operator(): Index out of range!");
   return _m[row][col];
}    // unary negation operator
template 
inline matrix matrix::operator - () _NO_THROW
{
   matrix temp(Row,Col);       for (size_t i=0; i 
inline ostream& operator << (ostream& ostrm, const matrix& m)
{
   for (size_t i=0; i < m.RowNo(); i  )
   {
      for (size_t j=0; j < m.ColNo(); j  )
      {
         T x = m(i,j);
         ostrm << x << '\t';
      }
      ostrm << endl;
   }
   return ostrm;
}    // ====================binary matrix operator===================
// binary matrix dot multiplication
template  
inline matrix matrix::operator * (const matrix& m) _THROW_MATRIX_ERROR
{ matrix temp(*this);
          if ( Row != m.Row || Col != m.Col)
       REPORT_ERROR( "matrix::operator = : Inconsistent matrix sizes in addition!");        for (size_t i=0; i < m.Row; i  )
      for (size_t j=0; j < m.Col; j  )
             temp._m[i][j] =_m[i][j]*m._m[i][j];
    return temp;
}    // binary right scalar multiplication
template  
inline matrix matrix::operator * (const T& c) _NO_THROW
{  matrix temp(*this);
    for (size_t i=0; i < Row; i  )
           for (size_t j=0; j < Col; j  )
            temp._m[i][j]*= c;
    return temp;
  }    // binary left scalar multiplication
template 
matrix& operator * (const T& c, const matrix& m) _NO_THROW
   {  return(m*c);
        }    //=======================================================        
void main()
{
  matrix Image(3,3);      Image(0,0)=4;
  Image(1,0)=2;
  Image(1,1)=8;
  Image(2,2)=5;      matrix Image3(3,3);      cout<    程式碼(二) 只po差異的部分    
  //=========class matrix declear==============================
template 
class matrix
{
    // Combined assignment - calculation operators
    matrix& operator *= (const T& c) _NO_THROW;
 };    // ============combined operator and assignment=====================    // combined scalar multiplication and assignment operator
template  
inline matrix& matrix::operator *= (const T& c) _NO_THROW
{
    for (size_t i=0; i < Row; i  )
           for (size_t j=0; j < Col; j  )
            _m[i][j] *= c;
    return *this;
}    // ======base binary operator using comine operator to implement===
// binary right scalar multiplication operator
template  
inline matrix operator * (const matrix& m, const T& no) _NO_THROW
{
   matrix temp = m;
   temp *= no;
   return temp;
}    // binary left scalar multiplication operator
template  
inline matrix operator * (const T& no, const matrix& m) _NO_THROW
{
   return (m * no);
}
    發表人 - senboy 於 2005/03/15  22:45:02