矩陣

在說矩陣前，先說一小小點關於數組的知識： 數組分爲兩種：

• 行主映射
  從第一行開始，依次對沒一行的索引從左至右連續編號。
• 列主映射
  對索引的編號從最左列開始，依次對每一列的索引從上到下連續編號。

---

• 不規則的二維數組
  但一個二維數組有兩行或者更多的行，每一行的元素個數不等時，這個數組就被稱爲不規則數組。對應的，所謂規則數組，即爲每行元素個數相同的二維數組。

一個m×n的矩陣，是一個m行、n列的表，m和n是矩陣的維數。
矩陣主要完成的操做有三種：

• 矩陣相加
• 矩陣轉置
• 矩陣相乘
  這三個概念，大學線性代數的課程裏都講過，這裏就不贅述。
  下面直接上代碼：
  matrix.cpp

/*
 * 矩陣測試代碼
 * matrix.cpp
*/
#include<iostream>
#include"matrix.h"

using namespace std;

int main(void)
{
   //測試矩陣類
    matrix<int> x(3,2),y,z;
    int i,j;
    for(i = 1;i<=3;i++)
        for(j = 1;j<=2;j++)
            x(i,j) = 2*i+j;
    cout << "Initalized x(x,j) = 2*i + j"<<endl;
    cout <<"x(3,1) = "<<x(3,1)<<endl;
    cout<<"The metrix x is:"<<endl;
    cout <<x;

    //矩陣賦值
    y = x;
    cout<<"The matrix y is:"<<endl;
    cout <<y;

    //兩個矩陣相加結果
    z = y + x;
    cout <<"y + x is"<<endl;
    cout<<z;

    //矩陣求負
    cout<<"-(y+x) is "<<endl;
    cout<<-z;

    //矩陣相乘
    matrix<int> w(2,3);
    for(i=1;i<=2;i++)
    {
        for(j=1;j<=3;j++)
        {
            w(i,j) = i+j;
        }
    }
    cout<<"Initialized w(i,j) = i+j"<<endl;
    cout<<"w is "<<endl;
    cout<< w <<endl;
    z = y*w;
    cout<<"y * w is"<<endl;
    cout<< z<<endl;


    cout<<"Hello World!"<<endl;
    return 0;
}

matrix.h

/*
 * 矩陣類，實現了矩陣的一些基礎性質：矩陣相加，相乘，矩陣轉置
 * matrix.h
*/
#ifndef MATRIX_H
#define MATRIX_H

#include"myexceptions.h"

using namespace std;

template<class T>
class matrix
{
    friend ostream& operator<<(ostream&,const matrix<T>&);
public:
    //構造函數
    matrix(int theRows = 0,int theColumns = 0);

    //複製構造函數
    matrix(const matrix<T>&);

    //析構函數
    ~matrix(){delete [] element;}

    int rows() const {return theRows;}//返回數組行數
    int columns() const {return theColumns;}//返回數組列數

    T& operator()(int i,int j) const;//對"()"進行運算符重載
    matrix<T>& operator=(const matrix<T>&);//對"="進行運算符重載
    matrix<T> operator+()const;//非數組「+」
    matrix<T> operator+(const matrix<T>&) const;//數組相加
    matrix<T> operator-()const;//非數組減
    matrix<T> operator-(const matrix<T>&) const;//數組減
    matrix<T> operator*(const matrix<T>&) const;//數組乘
    matrix<T>& operator+=(const T&);
private:
    int theRows;//數組的行數
    int theColumns;//數組的列數
    T *element;//元素數組
};

/*
 * 如下是對類內各類函數的具體實現
*/

//構造函數
template<class T>
matrix<T>::matrix(int theRows, int theColumns)
{
    if(theColumns < 0 || theRows < 0)
        throw illegalParameterValue("Rows and Columns must be >= 0");
    if((theRows == 0 || theColumns == 0)
            && (theRows != 0 || theColumns != 0))
        throw illegalParameterValue("Either both or neither rows and columns should be zero");

    ///建立矩陣
    this->theColumns = theColumns;
    this->theRows = theRows;
    element = new T[theRows*theColumns];
}

//複製構造函數
template<class T>
matrix<T>::matrix(const matrix<T> &m)
{
    theRows = m.theRows;
    theColumns = m.theColumns;
    element = new  T [theRows*theColumns];

    copy(m.element,
         m.element+theColumns*theRows,
         element);
}

//「=」重載
template<class T>
matrix<T>& matrix<T>::operator=(const matrix<T>& m)
{
    if(this != &m)
    {
        delete [] element;
        theRows = m.theRows;
        theColumns = m.theColumns;
        element = new T[theColumns*theRows];

        copy(m.element,m.element+theRows*theColumns,element);
    }
    return *this;
}

//"()"重載
template<class T>
T& matrix<T>::operator ()(int i,int j) const
{
    if(i<1 || i > theRows
        || j < 1 || j > theColumns)
        throw matrixIndexOutOfBounds();
    return element[(i-1)*theColumns+j-1];
}

//"+"重載
template<class T>
matrix<T> matrix<T>::operator+(const matrix<T>& m)const
{
    if(theRows != m.theRows
            || theColumns != m.theColumns)
        throw matrixSizeMismatch();

    matrix<T> w(theRows,theColumns);//建立結果矩陣w
    for(int i = 0;i< theRows*theColumns;i++)
        w.element[i] = element[i] + m.element[i];
    return w;
}

//"-"重載
template<class T>
matrix<T> matrix<T>::operator - (const matrix<T>& m)const
{
    if(theRows != m.theRows
            || theColumns != m.theColumns)
        throw matrixSizeMismatch();

    matrix<T> w(theRows,theColumns);//建立結果數組
    for(int i = 0;i< theColumns*theRows;i++)
        w.element[i] = element[i]-m.element[i];

    return w;
}

template<class T>
matrix<T> matrix<T>::operator - () const
{
    matrix<T> w(theRows,theColumns);
    for(int i = 0;i<theColumns*theRows;i++)
        w.element[i] = -element[i];
    return w;
}

//"*"重載,實現數組乘法
template<class T>
matrix<T> matrix<T>::operator * (const matrix<T>& m) const
{
    //計算(*this)*m的結果
    if(theColumns != m.theRows)
        throw matrixSizeMismatch();

    matrix<T> w(theRows,m.theColumns);
    int ct = 0,cm = 0,cw = 0;
    for(int i = 1;i <= theRows;i++)
    {
        for(int j = 1;j <= m.theColumns;j++)
        {
            T sum = element[ct] * m.element[cm];

            for(int k = 2;k<=theColumns;k++)
            {
                ct++;
                cm += m.theColumns;
                sum += element[ct]*m.element[cm];
            }
            w.element[cw++] = sum;
            ct -= theColumns - 1;
            cm = j;
        }
        ct += theColumns;
        cm = 0;
    }

    return w;
}

template<class T>
ostream& operator<<(ostream& out,const matrix<T>& m)
{
    int k = 0;
    for(int i = 0;i < m.theRows;i++)
    {
        for(int j = 0;j < m.theRows;j++)
            out << m.element[k++] << " ";

        out <<endl;
    }
    return out;
}

ostream& operator <<(ostream& out,const matrix<int>& m)
{
    int k = 0;
    for(int i = 0;i < m.theRows;i++)
    {
        for(int j = 0;j < m.theColumns;j++)
            out << m.element[k++] <<" ";
        out <<endl;
    }
    return out;
}

#endif // MATRIX_H

myExceptions.h

/*
 *異常類
 * myExceptions.h
*/
#ifndef MYEXCEPTIONS_H
#define MYEXCEPTIONS_H

#include<string>
using namespace std;

//參數值不合法
class illegalParameterValue
{
  public:
    illegalParameterValue(string theMessage = "Illegal parameter value")
    {
        message = theMessage;
    }
    void outputMessage()
    {
        cout << message <<endl;
    }
private:
    string message;
};

//矩陣索引值越界
class matrixIndexOutOfBounds
{
  public:
    matrixIndexOutOfBounds
                  (string theMessage = "Matrix index out of bounds")
    {
        message = theMessage;
    }
    void outputMessage()
    {
        cout <<message <<endl;
    }
private:
    string message;
};

class matrixSizeMismatch
{
  public:
    matrixSizeMismatch
             (string theMessage = "The size of the two matrics doesn't match")
    {
        message = theMessage;
    }
    void outputMessage()
    {
        cout << message <<endl;
    }
private:
    string message;
};

#endif // MYEXCEPTIONS_H