Место записи нарушения прав доступа в двойном вложенном цикле for

Question

Я конвертировал свой процедурный код MATLAB в OO C ++, и до сих пор это был довольно полезный опыт. Я получаю сообщение об ошибке «0xC0000005: место записи нарушения прав доступа 0xFDFDFE05», и я не уверен, что это означает.

Вот мой код MATLAB, который работает:

ms = 0;
for s = 1:Nx
    for m = 1:Ny
        ms = ms + 1;
        np = 0;
        for p = 1:Nx
        for n = 1:Ny
             np = np + 1;

             Xm = (m-0.5)*delta_x;
             Ys = (s-0.5)*delta_y;

             Xa = (n-1)*delta_x;
             Xb = n*delta_x;
             Ya = (p-1)*delta_y;
             Yb = p*delta_y;

             a  = (Yb-Ys);
             b  = (Xb-Xm);
             c  = (Ya-Ys);
             d  = (Xa-Xm);
             numA = b + sqrt(b.^2+a.^2);
             denA = d + sqrt(d.^2+a.^2);
             numB = a + sqrt(b.^2+a.^2);
             denB = c + sqrt(b.^2+c.^2);
             numC = d + sqrt(d.^2+c.^2);
             denC = b + sqrt(b.^2+c.^2);
             numD = c + sqrt(d.^2+c.^2);
             denD = a + sqrt(d.^2+a.^2);
             A = a.*log(numA./denA);
             B = b.*log(numB./denB);
             C = c.*log(numC./denC);
             D = d.*log(numD./denD);

             Z1(ms,np) = (A+B+(C+D))*k;
             end
         end
    end
end

Ниже приведена функция, расположенная в cpp-файле вне main.cpp. (РЕДАКТИРОВАТЬ: я внес изменения, предложенные в комментариях ниже, и теперь он работает, как ожидалось.)

double** zMatrix(double deltaX, double deltaY, double Nx, double Ny) {

double** Z = allocateMatrix(Nx*Nx, Ny*Ny);
int ms = 0;
for (int s = 0; s < Nx; s++)
{
    for (int m = 0; m < Ny; m++)
    {
        int np = 0;
        for (int p = 0; p < Nx; p++)
        {
            for (int n = 0; n < Ny; n++)
            {

                // Center of each observer patch
                double Xm = (m - 0.5) * deltaX;
                double Ys = (s - 0.5) * deltaY;

                // Source coordinates w/ corner (Xa, Ya) @ the origin (0, 0)
                // Lowest order basis function set:
                double Xa = (n - 1) * deltaX;
                double Xb = n * deltaX;
                double Ya = (p - 1) * deltaY;
                double Yb = p * deltaY;

        // Building analytical solution
                double a = (Yb - Ys);
                double b = (Xb - Xm);
                double c = (Ya - Ys);
                double d = (Xa - Xm);
                double numA = b + hypot(b, a); // sqrt(b*b + a * a);
                double denA = d + hypot(d, a); // sqrt(d*d + a * a);
                double numB = a + hypot(b, a); // sqrt(b*b + a * a);
                double denB = c + hypot(b, c); // sqrt(b*b + c * c);
                double numC = d + hypot(d, c); // sqrt(d*d + c * c);
                double denC = b + hypot(b, c); // sqrt(b*b + c * c);
                double numD = c + hypot(d, c); // sqrt(d*d + c * c);
                double denD = a + hypot(d, a); // sqrt(d*d + a * a);
                double A = a * log(numA / denA);
                double B = b * log(numB / denB);
                double C = c * log(numC / denC);
                double D = d * log(numD / denD);

                Z[ms][np] = (A + B + (C + D)) * k;
                np++;
            }
        }
        ms++;
    }
}
return Z;
} 

Вот моя матричная функция размещения:

double** allocateMatrix(double width, double height)
{
    // allocate the matrix
    double** zMatrix = new double*[width];
    for (int i = 0; i < width; i++)
    {
    zMatrix[i] = new double[height];
    }
    return zMatrix;
}

А потом в main.cpp я просто называю это так:

double** Z = zMatrix(deltaX, deltaY, Nx, Ny);

Я (обычно) довольно хорош и отлаживаю, но на самом деле это не дает мне много работы.

Вот захват переменных во время выполнения, где я думаю, что ошибка указывает, то есть Z [мс]:

Answer 1

Вы пишете (width*height) x (width*height) элементов в матрицу width x height.Таким образом, вы пишете без границ.

Я думаю, вы могли бы исправить это с помощью:

double** Z = allocateMatrix(width*height, width*height);