1.  
          A   (*ga)[n]   =   new   A[m][n];  
          ...  
          delete   []ga;  
  缺点：n必须是已知  
  优点：调用直观，连续储存，程序简洁(经过测试，析构函数能正确调用)  
   
  2.     A**   ga   =   new   A*[m];  
          for(int   i   =   0;   i   <   m;   i++)  
                  ga[i]   =   new   A[n];  
          ...  
          for(int   i   =   0;   i   <   m;   i++)  
                  delete   []ga[i];  
          delete   []ga;  
  缺点：非连续储存，程序烦琐，ga为A**类型  
  优点：调用直观，n可以不是已知  
   
  3.     A*   ga   =   new   A[m*n];  
          ...  
          delete   []ga;  
  缺点：调用不够直观  
  优点：连续储存，n可以不是已知  
   
  4.     vector<vector<A>   >   ga;  
          ga.resize(m);                                               //这三行可用可不用  
          for(int   i   =   1;   i   <   n;   i++)                     //  
                  ga[i].resize(n);                                 //  
          ...  
   
  缺点：非连续储存，调试不够方便，编译速度下降，程序膨胀(实际速度差别不大)  
  优点：调用直观，自动析构与释放内存，可以调用stl相关函数，动态增长  
   
  5.     vector<A>   ga;  
          ga.resize(m*n);  
  方法3,4的结合  
   
   
  6.   2的改进版(Penrose提供，在此感谢)  
          A**   ga   =   new   A*[m];  
          ga[0]   =   new   A[m*n];  
          for(int   i   =   1;   i   <   m;   i++)  
                  ga[i]   =   ga[i-1]+n;  
          ...  
          delete   []   ga[0];  
          delete   []   ga;  
  缺点：程序烦琐，ga为A**类型  
  优点：连续储存，调用直观，n可以不是已知  
   
  个人推荐1和4,2可以用4来代替，3,5调用太烦琐，毕竟源程序是拿来看的  
  不是拿来运行的  
   
   
  下面是一些错误和没成功的版本  
   
  1.   A*   ga   =   new   A[m][n];  
      必然错误  
   
  2.   vector<A[n]>   ga;  
        ga.resize(m);