泛型矩阵类

矩阵就不用再解释了，写成泛型主要是为了几个方便：
1、方便在栈上分配空间。由于维度在编译期已知，所以可以做到在栈上分配空间。当然如果这个对象是new出来的，自然是在堆上分配，这里说的是在栈上分配这个对象时，矩阵元素所占用的空间也在栈上分配。
2、方便在编译期检查非法的矩阵运算。C++模板的强大推导能力可以在编译期推导出结果矩阵的维度。
3、泛型类在方法内联上具有优势。

这个矩阵类为了能够直接从数组赋值，使用了一个ArrayPorxy类（可参考《Imperfect C++》）。

代码如下：

template  < class  T,  int  D1,  int  D2 = 1 >
class  ArrayProxy
{
    T *  data;
public :
    ArrayProxy(T ( & value)[D1][D2])
        : data( & value[ 0 ][ 0 ])
    {
    }

    ArrayProxy(T ( & value)[D1 * D2])
        : data(value)
    {
    }

    T *  getData()  const
    {
         return  data;
    }
};

这个只是简单的实现。

因为我基本上不使用这个矩阵类，所以只完成几个简单功能：
1、从数组赋值：
int a[][3] = {{1,2,3}, {4,5,6}};
Matrix<int, 2, 3> m1(a);
或
int a[] = {1,2,3, 4,5,6};
Matrix<int, 2, 3> m1(a);
Matrix<int, 3, 2> m2(a);
Matrix<int, 6, 1> m3(a);
Matrix<int, 1, 6> m4(a);

2、矩阵乘法：
Matrix<int, 2, 3> m1;
Matrix<int, 2, 4> m2;
// m1 * m2  <== 编译错误，维度不匹配
Matrix<int, 3, 5> m3;
Matrix<int, 2, 5> m4 = m1 * m3; // <== 合法
// m3 * m1; // <== 编译错误，维度不匹配

源码如下：

template <class T, int R, int C>
class Matrix
{
    T matrix[R][C];

public:
    // Big three
    Matrix(void)
    {
        memset(matrix, 0, sizeof(matrix));
    }

    Matrix(const Matrix& rhs)
    {
        memcpy(matrix, rhs.matrix, sizeof(matrix));
    }

    Matrix& operator =(const Matrix& rhs)
    {
        memcpy(matrix, rhs.matrix, sizeof(matrix));
        return *this;
    }

public:
    Matrix(const ArrayProxy<T,R,C>& arr)
    {
        memcpy(matrix, arr.getData(), sizeof(matrix));
    }

    ~Matrix(void)
    {
    }

public:
    T get(int r, int c) const
    {
        assert(c < C && c >= 0 && r < R && r >= 0);
        return matrix[r][c];
    }

    void set(int r, int c, T v)
    {
        assert(c < C && c >= 0 && r < R && r >= 0);
        matrix[r][c] = v;
    }

    int getCols () const
    {
        return C;
    }

    int getRows () const
    {
        return R;
    }

    bool operator == (const Matrix& rhs) const
    {
        return memcmp(matrix, rhs.matrix, sizeof(matrix)) == 0;
    }

    bool operator != (const Matrix& rhs) const
    {
        return !(*this == rhs);
    }
};

template <class T, int R, int C, int C1>
Matrix<T,R,C1> operator* (const Matrix<T,R,C>& lhs, const Matrix<T,C,C1>& rhs)
{
    Matrix<T,R,C1> result;
    for (int r=0; r<R; ++r)
    {
        for (int c=0; c<C1; ++c)
        {
            int value = 0;
            for (int i=0; i<C; ++i)
            {
                value += lhs.get(r,i) * rhs.get(i,c);
            }
            result.set(r,c,value);
        }
    }
    return result;
}

测试代码：

int main()
{
    {
        // 测试初始化
        Matrix<int, 3, 4> m1;
        Matrix<int, 3, 4> m2(m1);
        Matrix<int, 3, 4> m3 = m1;
        Matrix<int, 3, 4> m4;
        m4 = m1;

        for (int i=0; i<3; i++)
            for (int j=0; j<4; j++)
            {
                assert (m1.get(i, j) == 0);
                assert (m2.get(i, j) == 0);
                assert (m3.get(i, j) == 0);
                assert (m4.get(i, j) == 0);
            }

        int a[] = {1,2,3,4, 5,6,7,8, 9,10,11,12};
        Matrix<int, 3, 4> m5(a);

        int b[3][4] = { {1,2,3,4},
                        {5,6,7,8},
                        {9,10,11,12}};

        Matrix<int, 3, 4> m6(b);

        Matrix<int, 3, 4> m7(m5);
        Matrix<int, 3, 4> m8 = m5;
        Matrix<int, 3, 4> m9;
        m9 = m5;

        for (int i=0; i<3; i++)
            for (int j=0; j<4; j++)
            {
                assert (m5.get(i, j) == i*4+j+1);
                assert (m6.get(i, j) == i*4+j+1);
                assert (m7.get(i, j) == i*4+j+1);
                assert (m8.get(i, j) == i*4+j+1);
                assert (m9.get(i, j) == i*4+j+1);
            }

        // 维数不匹配，编译错误
        // Matrix<int, 4, 5> m10 = m9;
        int c[][2] = {{1,2}, {2,3}};
        // 数组大小不匹配，编译错误
        //Matrix<int, 3, 4> m10(c);
        int d[] = {1,2};
        // 数组大小不匹配，编译错误
        //Matrix<int, 3, 4> m11(d);

        // 乘法维数不合适，无法相乘
        //m1 * m2;

        Matrix<int,4,3> m12;
        // 匹配，可以相乘
        Matrix<int, 3, 3> m13 = m1 * m12;

        Matrix<int, 8, 3> m14;
        // 无法相乘
        //Matrix<int, 3, 3> m15 = m1 * m14;
        // 可以相乘
        Matrix<int, 8, 4> m15 = m14 * m1;
    }

    {
        // 检查点乘
        int a[2][5] = {{1,2,3,4,5}, {6,7,8,9,10}};
        Matrix<int, 2, 5> m1(a);

        int b[5][3] = {{1,2,3}, {4,5,6}, {7,8,9}, {10,11,12}, {13,14,15}};
        Matrix<int, 5, 3> m2(b);

        int c[2][3] = {{135,150,165}, {310,350,390}};
        Matrix<int, 2, 3> m3(c);

        Matrix<int, 2, 3> m4 = m1 * m2;
        assert(m4 == m3);

        cout << m4.get(0,0) << endl;
    }

    return 0;
}

补充：
1、加法、减法只需要2个矩阵维度相同即可。

template <class T, class R, class C>
Matrix<T,R,C> operator+ (const Matrix<T,R,C>& lhs, const Matrix<T,R,C>& rhs)
{
   // 
}

2、由于1x1的矩阵可以看成一个标量，矩阵与标量运算结果维数与原矩阵相同，可以重载来实现。

template <class T, class R, class C>
Matrix<T,R,C> operator* (const Matrix<T,R,C>& lhs, const Matrix<T,1,1>& rhs)
{
    // 
}

3、由于类型泛化，可能某些合理的运算无法进行，比如float型矩阵，与一个int型标量运算等。这些最好是借助类型萃取等手段，推导出运算以后的类型。（c++0x中包含自动获取运算结果类型的关键字typeof，等几年就可以用了:)。GCC编译器中已有实现，不过似乎有BUG）。

4、其它。泛型实现可能会有一些考虑不周的地方，强类型有强类型的好处，不过必须要有完整的泛型算法支撑，否则难以使用。也可以把泛型矩阵类从一个普通矩阵类派生，这样更容易写出通用算法，不过在实现上可能要借助于运行期多态，对于矩阵类来说并不合适。

5、其它。。前面说C＋＋的模板相当强大，D语言模板到目前为止似乎已经完全实现了C＋＋模板的功能，还增加了一些比如字符串值参模板等特性，比C＋＋模板功能更多。在代码编写上，由于可以编写静态判断语句（编译期）以及静态断言，编写模板比C＋＋更容易。有时间可以试试用它写个矩阵类，纯粹是兴趣，这些东西真的很难用到，现成的库也挺多。

6、其它。。。c++0x要提供“template typedef”，也就是可以这样定义：
template <int R, int C> typedef Matrix<int, R, C> MatrixInt;  // 定义类型，维度不定
template <class T> typedef Matrix<T, 4, 4> Matrix4x4; // 定义维度，类型不定
由此可以出定义行向量、列向量、标量等，当然实际使用起来可能没那么舒服了。