Code Randomly Crashes

[AliMoradi]

I have a code that is randomly crashing on me without any explanations. I'm not sure what is going on. When I run the code, it says that the .exe file has stopped working, and the command window displays the following:

"Process returned -1073741819 <0xC0000005> execution time : 16.747 s. Press any key to continue.

My compiler says the same thing without giving me any details.

I thought maybe I had an infinite while loop going on, but when I turn off my while loop, the code still crashes. I also tested out my function, SGN, to make sure that it works, and that doesn't seem to be the problem. The only thing that I can think of is the way I'm dynamically allocating my 2D arrays, U and E, and my 1D array, t. But on a previous thread, I thought I had this resolved, so I'm not totally sure.

I've attached my code for reference. I'm using CodeBlocks as my compiler. I really appreciate any help that I can get!

#include <iostream>
#include <math.h>
#include <stdio.h>
#include <fstream>
#include <cmath>
#include <algorithm>

#define pi 3.14159265

using namespace std;

const int M = 40; //X-Grid Intervals
double L0 = -1;
double LF = 1;
double tmax = 0.15; //Final Time
int N = 40; //Maximum t-vector Size

//Dynamic Memory Allocation
double ** U;
double ** E;
double * t = new double [N];

int SGN(double aP)
{
    if (aP > 0)
    return 1;
    else if (aP == 0)
    return 0;
    else if (aP < 0)
    return -1;
}


int main()
{
    //Create X Vector and Initial Conditions
    double x [M+1];
    U = new double * [M+1];
    E = new double * [M+1];
    for ( int i = 0; i < M + 1; i++ ) * U = new double [N];
    for ( int i = 0; i < M + 1; i++ ) * E = new double [N];
    x[0] = L0;
    x[M] = LF;
    for (int i = 1; i < M; i++)
    {
        x[i] = -1 + (i - 0.5)*2/M;
        U[i][0] = 0.25 + 0.5*sin(pi*x[i]);
        E[i][0] = 0.5*U[i][0]*U[i][0];
    }
    U[0][0] = U[M-1][0];
    E[0][0] = 0.5*U[0][0]*U[0][0];
    U[M][0] = U[1][0];
    E[M][0] = 0.5*U[M][0]*U[M][0];
    double dx = x[2] - x[1];

    //Allocate Variables and Vectors
    double DUP;
    double DUM;
    double aP [M+1];
    double aM [M+1];
    double dtt [M+1];
    double dt;

    t[0] = 0;

    int s = 0;
    int ERR = 0;
    while (ERR == 0)
    {
        //Calculate Alpha and Time Step
        for (int i = 1; i < M; i++)
        {
            DUP = U[i+1][s] - U[i][s];
            DUM = U[i][s] - U[i-1][s];
            if (DUP == 0)
            {
                aP[i] = U[i][s];
            }
            else
            {
                aP[i] = (E[i+1][s] - E[i][s])/(U[i+1][s] - U[i][s]);
            }
            if (DUM == 0)
            {
                aM[i] = U[i][s];
            }
            else
            {
                aM[i] = (E[i][s] - E[i-1][s])/(U[i][s] - U[i-1][s]);
            }

            dtt[i] = dx/abs(aP[i]);

        }

        //Find Minimum Time Step and Round To Low Value
        dt = dtt[1];
        for (int i = 2; i < M; i++)
        {
            if (dtt[i] < dt)
            {
                dt = dtt[i];
            }
        }

        //Even Out Time Step
        if (t[s] + dt > tmax)
        {
            dt = tmax - t[s];
        }

        //Calculate Solution For New Time Step
        for (int i = 1; i < M; i++)
        {
            U[i][s+1] = U[i][s] - 0.5*dt/dx*(1 - SGN(aP[i]))*(E[i+1][s] - E[i][s]) - 0.5*dt/dx*(1 + SGN(aM[i]))*(E[i][s] - E[i-1][s]);
            E[i][s+1] = 0.5*U[i][s+1]*U[i][s+1];
        }
        //Period Boundary Condition
        U[0][s+1] = U[M-1][s+1];
        U[M][s+1] = U[1][s+1];
        E[0][s+1] = 0.5*U[0][s+1]*U[0][s+1];
        E[M][s+1] = 0.5*U[M][s+1]*U[M][s+1];

        //Calculate New Time
        t[s+1] = t[s] + dt;
        s = s + 1;

        //Expand Arrays
        if (s >= N)
        {
            N = N*2;
            double ** temp;
            double ** temp2;
            double * temp3 = new double [N];
            temp = new double * [M+1];
            temp2 = new double * [M+1];
            for ( int i = 0; i < M + 1; i++ ) * temp = new double [N];
            for ( int i = 0; i < M + 1; i++ ) * temp2 = new double [N];
            for (int j = 0; j < s; j++)
            {
                for (int i = 0; i < M+1; i++)
                {
                    temp[i][j] = U[i][j];
                    temp2[i][j] = E[i][j];
                }

                temp3[j] = t[j];
            }

            delete [] U;
            delete [] E;
            delete [] t;
            U = temp;
            E = temp2;
            t = temp3;

        }

        //Check To See If T-max Has Been Reached
        if (t[s] >= tmax)
        {
            ERR = 1;
        }

    }

    //Output Data Into Text File
    ofstream outputdata("timevector.txt");
    for (int i = 0; i<N; i++)
    {
        outputdata << t[i] << endl;
    }
    outputdata.close();

    ofstream outputdata3("xvector.txt");
    for (int j = 0; j<M+1; j++)
    {
        outputdata3 << x[j] << endl;
    }
    outputdata3.close();

    ofstream outputdata2("U.txt");
    for (int i = 0; i<N; i++)
    {
        for (int j = 0; j<M+1; j++)
        {
            outputdata2 << U[j][i] << endl;
        }
    }
    outputdata2.close();


    return 0;


}

[guestgulkan]

To start with - I would re-check the following two lines

int main()
{
    //Create X Vector and Initial Conditions
    double x [M+1];
    U = new double * [M+1];
    E = new double * [M+1];
    for ( int i = 0; i < M + 1; i++ ) * U = new double [N]; //????????????????????
    for ( int i = 0; i < M + 1; i++ ) * E = new double [N]; //??????????????????????? 

[AliMoradi]

I will admit, I'm not exactly sure what that line of code is doing. A couple of days ago, I had started a thread about dynamically allocating 2D arrays and that's what someone recommended to me. Here is the link to the thread:

http://www.cplusplus.com/forum/beginner/67879/

When I followed their advice, it seemed to get rid of all my old errors, but everything kept on crashing (as explained above). I must have misunderstood their suggestion or something.

[guestgulkan]

the poster made a mistake:
You have a couple of choices (veyr simple fix):

Choice 1 - using array notation

    for ( int i = 0; i < M + 1; i++ )  U[i] = new double [N];
    for ( int i = 0; i < M + 1; i++ )  E[i] = new double [N];

OR

Choice 2 - using pointer notation

    for ( int i = 0; i < M + 1; i++ )  *(U+i) = new double [N];
    for ( int i = 0; i < M + 1; i++ )  *(E+i) = new double [N];

You also need to do the same later on when:

           for ( int i = 0; i < M + 1; i++ ) * temp = new double [N]; //do the same as above
            for ( int i = 0; i < M + 1; i++ ) * temp2 = new double [N];//do same as above
          

Other issues:

1. Your delete functions are wrong as well - your are leaking memory like a sieve.
Change to:

            for ( int i = 0; i < M + 1; i++ )  delete [] U[i] ;
            for ( int i = 0; i < M + 1; i++ )  delete [] E[i] ;       
            delete [] U;
            delete [] E;
            delete [] t;

2. This function is incomplete - as it is possible to exit the function
without providing a value (your compiler should have warned you as such

int SGN(double aP)
{
    if (aP > 0)
    return 1;
    else if (aP == 0)
    return 0;
    else if (aP < 0)
    return -1;
}

change it to:

int SGN(double aP)
{
    if (aP > 0)
    return 1;
    else if (aP == 0)
    return 0;
   //you have already accounted for ap>0 and ap==0
//so if we get here ap must be greater than 0
//so just return -1 
    return -1;
}

That's all for now... once you have done those we can go on from there.

[Lowest0ne]

I had troubles with an array such as this. A little background, the file I was reading had an integer rep which would be the amount of sections. In each section was a character array, the 4 bytes before it being an integer for how long the array would be.

I idea was, make the first dimension from the first rep, and then have varied sizes of the 2nd dimension. I guess we can't do this with arrays. I settled to have the 2nd dimension be something larger than it would ever need to be, but I would imagine your global variable would work the same (Which begs the question, why even make them dynamically if you know what size they are going to be?).

Here is the snipet of code, the parenthesis are important:

unsigned char (*u53String)[64];
u53String = new unsigned char [u53Rep][64];

I think if they were both dynamic, you would want something like this: *(*variable);

[AliMoradi]

the poster made a mistake:
You have a couple of choices (veyr simple fix):

Choice 1 - using array notation

for ( int i = 0; i < M + 1; i++ )  U[i] = new double [N];
for ( int i = 0; i < M + 1; i++ )  E[i] = new double [N];

You're the man! Things are working out perfectly. Is there any way you can explain to me how the language is handling this in order to dynamically allocate the memory? It seems to me that I'm creating a vector (1D) and then through the for-loop, I'm adding another vector of size N to each element of my first vector. It's just the way that it's coded makes no sense to me.

Other issues:

1. Your delete functions are wrong as well - your are leaking memory like a sieve. We'll fix that later..

What's the best way to go about this? I was always told that in C++ you want to get rid of those unnecessary vectors and the best way to do them was to just use 'delete'.

[long double main]

Err, but you have to make sure you delete[] everything.

That would mean (I haven't really looked at your code; sorry if this is wrong)

for (int i = 0; i < M + 1; ++i)
{
    delete[] U[i];
    delete[] E[i];
}
delete[] U;
delete[] E;

[Lowest0ne]

2. This function is incomplete - as it is possible to exit the function
without providing a value (your compiler should have warned you as such

Although I agree that the way you corrected makes more sense, there isn't a case where that function wouldn't return anything.

[AliMoradi]

Err, but you have to make sure you delete[] everything.

That would mean (I haven't really looked at your code; sorry if this is wrong)

for (int i = 0; i < M + 1; ++i)
{
    delete[] U[i];
    delete[] E[i];
}
delete[] U;
delete[] E;

Do you have to do the for-loop because it's a 2D array? I was always under the impression that 'delete []' would simply erase everything.

Also, another thing I noticed is that my code runs fine unless it has to utilize the following section (expanding arrays). This section seems to crash my program every time. Is it perhaps the way I'm allocating my arrays? I'm using the same method as above, so it shouldn't be doing that. Or is it because I have to run a for-loop when equation U = temp, E = temp2, t = temp3?

//Expand Arrays
        if (s >= N)
        {
            N = N*2;
            double ** temp;
            double ** temp2;
            double * temp3 = new double [N];
            temp = new double * [M+1];
            temp2 = new double * [M+1];
            for ( int i = 0; i < M + 1; i++ ) temp[i] = new double [N];
            for ( int i = 0; i < M + 1; i++ ) temp2[i] = new double [N];
            for (int j = 0; j < s; j++)
            {
                for (int i = 0; i < M+1; i++)
                {
                    temp[i][j] = U[i][j];
                    temp2[i][j] = E[i][j];
                }

                temp3[j] = t[j];
            }

            for (int i = 0; i < M+1; i++)
            {
                delete [] U[i];
                delete [] E[i];
            }

            delete [] U;
            delete [] E;
            delete [] t;
            U = temp;
            E = temp2;
            t = temp3;

        }