泛型矩阵类

矩阵就不用再解释了，写成泛型主要是为了几个方便：
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; // 定义维度，类型不定
由此可以出定义行向量、列向量、标量等，当然实际使用起来可能没那么舒服了。