Access violation writing location in double nested for-loop

Question

I've been converting my procedural MATLAB code into OO C++ and it has been quite the learning experience thus far. The error I'm getting is a "0xC0000005: Access violation writing location 0xFDFDFE05", and am not sure what this means.

The following is my MATLAB code, which works:

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

The following is the function, located in a cpp-file outside of main.cpp. (EDIT: I made the changes suggested in the comments below, and it now works as expected.)

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;
}

Here is my allocate matrix function:

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;
}

And then in main.cpp, I just call it like this:

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

I'm (usually) pretty good and debugging, but this one isn't really giving me much to work with.

Here's a capture of the variables during runtime, where I think the error points to, i.e. Z[ms]:

See `std:vector >`. Also check out using `new double [X_CAPACITY][Y_CAPACITY];` — Thomas Matthews, Jun 17 '19 at 23:40
BTW, prefer `x * x` rather than `pow(x,2)`. The former is more efficient and can be applied to integers. — Thomas Matthews, Jun 17 '19 at 23:45
You should declare variables as `const` if their value doesn't change, example: `const double a = (Yb - Ys);` It helps the computer optimize your code. — Thomas Matthews, Jun 17 '19 at 23:46
*0xFDFDFE05* is an extremely unlikely *0xFDFDFDFD +8*. Seeing something like this, I'd go looking in a list of debugging magic numbers to see what *0xFDFDFDFD* could mean. [And as I happen to have such a list](https://en.wikipedia.org/wiki/Magic_number_(programming)#Magic_debug_values) at my disposal, it looks like you've marched out of bounds of a heap allocation and stomped a heap guard. It's worth knowing your magic numbers. They can really help speed a diagnosis. — user4581301, Jun 18 '19 at 00:13
`pow(x,2)` can also give [wrong results, depending on compiler and compiler options](https://stackoverflow.com/questions/25678481/why-does-pown-2-return-24-when-n-5-with-my-compiler-and-os/25678721#25678721). Also, dynamically allocating a 2D array like that is one of the worst ways to do this for multiple reasons. See [this](https://stackoverflow.com/questions/21943621/how-to-create-a-contiguous-2d-array-in-c/21944048#21944048). — PaulMcKenzie, Jun 18 '19 at 00:21
And instead of `sqrt(pow(b, 2) + pow(a, 2))` use `std::hypot(a,b)`, which avoids overflow. — Cris Luengo, Jun 18 '19 at 00:43

score 1 · Accepted Answer · answered Jun 17 '19 at 23:48

1

You’re writing (width*height)x(width*height) elements to a widthxheight matrix. You are thus writing out of bounds.

I guess you might fix this with:

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

answered Jun 17 '19 at 23:48

Cris Luengo

55,762
10
62
120

Nice catch, np keeps increasing past the value of height while inside the inner most loop, thus causing the statement accessing out of bounds. – AntiqTech Jun 17 '19 at 23:55
1

@AntiqTech: both `np` and `ms` do this. MATLAB extents matrix when writing to it, so his issue wouldn’t show in the MATLAB code. – Cris Luengo Jun 18 '19 at 00:00
I made that change, but it is still giving me the same error. – Daniel Pavlovsky Jun 18 '19 at 00:00
1

@Daniel — Also, I just noticed that the C++ code has loops that are all 1 element shorter than in the MATLAB code, so there are more things to fix. – Cris Luengo Jun 18 '19 at 00:00
In Matlab code, if Nx and Ny are both '10' and my delta_x and delta_y are both '0.1', I get a 100x100 matrix. – Daniel Pavlovsky Jun 18 '19 at 00:36
1

@Daniel: Right. In C++ you need to iterate `<=width` etc. to match your MATLAB loop. You also need to move `ms++` to the end of the loop body so that you index starting at 0. C++ indexes starting at 0, MATLAB starting at 1. – Cris Luengo Jun 18 '19 at 00:39
1

Also, the deltas do not influence the matrix size. – Cris Luengo Jun 18 '19 at 00:40
Ok, it works now. I made the changes to my original post. Thanks for all your help! – Daniel Pavlovsky Jun 18 '19 at 01:06
1

@Daniel: Your C++ loops are all still one shorter than the MATLAB loops: `1:N` is equivalent to looping from 1 to `<=N`. – Cris Luengo Jun 18 '19 at 01:11
Sorry, yes, I had that changed in the code in VS, but forgot to update here. Thanks for pointing that out. – Daniel Pavlovsky Jun 18 '19 at 01:14

Access violation writing location in double nested for-loop

1 Answers1