类的成员函数定义如下
double** Mmatrix::WMmatrix(int ielem)
{
    int Ngauss;
    double Posgp[10];
    double Weigp[10];
    int iNxd,jNyd,iG,jG;
    double dSum;
    double** pMtr;
    double JaDet,Weight;

    TwoArrayAllocation pT;
    pMtr=pT.TwoArrayDoubleAlloc((Nx+1)*(Ny+1),(Nx+1)*(Ny+1));

    XYandPhaiDifferential JD;

    GaussianQuadrature(Ngauss,Posgp,Weigp);

    for(iNxd=0;iNxd<(Nx+1)*(Ny+1);iNxd++)
    {
        for(jNyd=0;jNyd<(Nx+1)*(Ny+1);jNyd++)
        {
            dSum=0;

            for(iG=0;iG<Ngauss;iG++)
            {
                for(jG=0;jG<Ngauss;jG++)
                {
                    JaDet=JD.JacobiDeterminant(ielem,Posgp[iG],Posgp[jG]);
                    Weight=Weigp[iG]*Weigp[jG];
                    pMtr=SumforDegree(Posgp[iG],Posgp[jG]);

                    dSum+=pMtr[iNxd][jNyd]*Weight*JaDet;
                }
            }
            
            pMtr[iNxd][jNyd]=dSum;

            cout<<"pMtr["<<iNxd<<"]["<<jNyd<<"]="<<pMtr[iNxd][jNyd]<<endl;
        }
    }

    return(pMtr);

    pT.DoubleTwoArrayFree((Nx+1)*(Ny+1),pMtr);
}
调用的语句为
    double** paT;
    int i,j;

    Mmatrix aTem;
    paT=aTem.WMmatrix(0);
            
    for(j=0;j<(Nx+1)*(Ny+1);j++)
    {
        for(i=0;i<(Nx+1)*(Ny+1);i++)
        {
            cout<<"paT["<<i<<"]["<<j<<"]="<<paT[i][j]<<endl;
        }
按理说两次输出结果应该相同，可是事实不是一样的，百思不得其解。望论坛上的高手赐教。

return(pMtr);
pT.DoubleTwoArrayFree((Nx+1)*(Ny+1),pMtr);
这个是什么意思？下面那句代码是无论如何也执行不到。
pMtr看上去是一个指针的指针，但从使用上来看，它只是一个指针，我不知道TwoArrayDoubleAlloc和SumforDegree返回的是什么，所以不好说是什么，只是dSum+=pMtr[iNxd][jNyd]*Weight*JaDet;
这句让我觉得它是一个指针，而不是指针的指针。

同意LS
 楼主写的太“模糊了”一些重要的信息没有交代
 还有能写中文就写中文注释吧，好理解一些。。。

回二楼：
return(pMtr);
pT.DoubleTwoArrayFree((Nx+1)*(Ny+1),pMtr);这两句表示由于
TwoArrayAllocation pT;
    pMtr=pT.TwoArrayDoubleAlloc((Nx+1)*(Ny+1),(Nx+1)*(Ny+1));
将pMtr申明为一个二级指针，指向一个二维数组，返回之后要释放它，但我不清楚返回之后是不是就结束函数了，如果是这样，那要到哪释放它？TwoArrayDoubleAlloc和SumforDegree返回的都是二级指针。还有pMtr[iNxd][jNyd]不是二级指针所指向的元素的值吗？

return语句后面的代码是不会执行的，直接返回了，另外要释放pMtr，哪返回它又有什么意义呢？应该是释放这个工作让调用者去做，也就是返回的地方，在使用完之后再去释放。

pMtr[iNxd][jNyd]并不是调用二级指针，实事上，这只是一个二维数组的调用方式，而二维数组并不是二级指针，还是一级指针。
pMtr[iNxd][jNyd]还可以写成 *(pMtr+iNxd*列数+jNyd)，所以它本质上是一级指针，在内存中，它还是一个一维数组，只是在代码层面人为地划分了行列，在概念上是二维数组。

如果pMtr是二级指针，指向的是一个二维数组，正确使用方法应该是：
(*pMtr)[iNxd][jNyd]
也就是说 *pMtr 为取出二维数组首地址，再用[iNxd][jNyd]来做下标偏移来访问数组元素。

而pMtr要成为二级指针，应该是：
double* p = new double[100];
pMtr = &p;

所以它到底是不是二级指针，最好把代码上传了。虽然pMtr被声明为二级指针，但没看到代码，还是不知道它是否被正确赋值了。

谢谢二楼和四楼的解答，为了使您能更清晰地了解程序的问题，我把所有的对象传上来。如下：
double** Mmatrix::WMmatrix(int ielem)
{
    int Ngauss;
    double Posgp[10];
    double Weigp[10];
    int iNxd,jNyd,iG,jG;
    double dSum;
    double** pMtr;
    double JaDet,Weight;

    TwoArrayAllocation pT;
    pMtr=pT.TwoArrayDoubleAlloc((Nx+1)*(Ny+1),(Nx+1)*(Ny+1));

    XYandPhaiDifferential JD;

    GaussianQuadrature(Ngauss,Posgp,Weigp);

    for(iNxd=0;iNxd<(Nx+1)*(Ny+1);iNxd++)
    {
        for(jNyd=0;jNyd<(Nx+1)*(Ny+1);jNyd++)
        {
            dSum=0;

            for(iG=0;iG<Ngauss;iG++)
            {
                for(jG=0;jG<Ngauss;jG++)
                {
                    JaDet=JD.JacobiDeterminant(ielem,Posgp[iG],Posgp[jG]);
                    Weight=Weigp[iG]*Weigp[jG];
                    pMtr=SumforDegree(Posgp[iG],Posgp[jG]);

                    dSum+=pMtr[iNxd][jNyd]*Weight*JaDet;

                    cout<<"Weight="<<Weight<<endl;
                    cout<<"JacobiDeterminant="<<JaDet<<endl;
                    cout<<"pMtr_0["<<iNxd<<"]["<<jNyd<<"]="<<pMtr[iNxd][jNyd]<<endl;
                }
            }
            
            pMtr[iNxd][jNyd]=dSum;

            cout<<"pMtr["<<iNxd<<"]["<<jNyd<<"]="<<pMtr[iNxd][jNyd]<<endl;
        }
    }

    return(pMtr);

    pT.DoubleTwoArrayFree((Nx+1)*(Ny+1),pMtr);
}

double** TwoArrayAllocation::TwoArrayDoubleAlloc(int nRow,int nCol)
{
    pToDoubleMatrix=new double* [nRow];
    if(!pToDoubleMatrix)
    {
        cout<<"内存分配失败！"<<endl;
        exit(-1);
    }
    for(int j=0;j<nRow;j++)
    {
        pToDoubleMatrix[j]=new double [nCol];
        if(!pToDoubleMatrix)
        {
            cout<<"内存分配失败！"<<endl;
            exit(-1);
        }
    }
    return pToDoubleMatrix;
}

double** Mmatrix::SumforDegree(double ksi,double nda)
{
    int i,j,k,l,inode,jnode;
    double** pLM;
    double aPhai;
    double bPhai;

    TwoArrayAllocation pTwoArray;
    pLM=pTwoArray.TwoArrayDoubleAlloc((Nx+1)*(Ny+1),(Nx+1)*(Ny+1));

    XYandPhaiDifferential Phai;

    inode=0;
    for(i=0;i<=Nx;i++)
        {
            for(j=0;j<=Ny;j++)
                {
                    aPhai=Phai.InterpolationCoord(i,j,ksi,nda);

                    inode++;

                    jnode=0;
                    
                    for(k=0;k<=Nx;k++)
                        {
                            for(l=0;l<=Ny;l++)
                                {
                                    bPhai=Phai.InterpolationCoord(k,l,ksi,nda);

                                    jnode++;

                                    pLM[inode-1][jnode-1]=aPhai*bPhai;
//                                    cout<<"pLM["<<inode-1<<"]["<<jnode-1<<"]="<<pLM[inode-1][jnode-1]<<endl;

                                }
                        }
                }
        }
        
        return(pLM);

    pTwoArray.DoubleTwoArrayFree((Nx+1)*(Ny+1),pLM);
 
}

void Mmatrix::GaussianQuadrature(int& Ngauss,double Posgp[10],double Weigp[10])
{
    Ngauss=2;
    Posgp[0]=-0.577350269189626;
    Weigp[0]=1;
    Posgp[1]=0.577350269189626;
    Weigp[1]=1;
    return;
}
所有相关的模块就这些，如果我对二级指针理解错了，肯定上面这些模块也有同样的错误，那问题可大了！请指教。

TwoArrayDoubleAlloc是返回的二级指针，
那么问题就是对二级指针的数组元素访问的错误和删除指针的时机问题，这个前面已经说过了。
pLM[inode-1][jnode-1]=aPhai*bPhai;
应该是
(*pLM)[inode-1][jnode-1]=aPhai*bPhai;

二级指针的删除时机，需要根据具体逻辑来，原则是在使用完之后，这个概念就是，一旦删除，就无法再使用这指针里的数组，直到再次分配新的。

把pLM[inode-1][jnode-1]=aPhai*bPhai;
改为
(*pLM)[inode-1][jnode-1]=aPhai*bPhai;编译时出现以下错误提示：
c:\Users\Documents\try\try.cpp(694) : error C2109: 下标要求数组或指针类型
请问，这是什么原因？

是我写搞错了，应该是
*(pLM[inode-1][jnode-1])=aPhai*bPhai;

还是不行，编译出现“c:\\try\try.cpp(632): error C2100: 非法的间接寻址”的错误提示！快晕倒了！