wrong output of programm, using pointers to an array of structs

Question

Im trying to run a simulation and create points as structs. I now want to store them in an array and tried to use a pointer on that array. When i run the programm, it just randomly gives me a wrong output. I suspect there is something wrong with the pointer "Point *Point" or the use of the malloc() funtion. when Im changing things it only gets worse and the programm doesnt even finish and gives me this error code: Process returned -1073741819 (0xC0000005)

I'd very happy if someone knew why its failing :)

This is my code

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define M_PI 3.14159265

//mx..+bx.+kx=p*sgn(x.)

double p=1;
double m=1;
double const_b=1;
double const_k=1;

typedef struct point{
    double counter;
    double x;
    double xDot;
}Point;

double DGL(double x, double xDot){
    int sgn=0;
    if(xDot>0){
        sgn=1;
    }
    else{
        sgn=-1;
    }
    double xDotDot = -const_b/m*xDot-const_k/m*x+p/m*sgn;
    return xDotDot;
}

Point *runSimulation(double time, double x_0, double step)
{
    double x=x_0;
    double xDot=0;
    double xDotDot=0;
    double counter=0;
    int i=0;

    Point *Point= malloc(time/step*sizeof(Point));

    while(counter<time)
    {
        xDotDot=DGL(x, xDot);
        xDot=xDot+xDotDot*step;
        x=x+xDot*step;

        Point[i].x=x;
        Point[i].xDot=xDot;
        Point[i].counter=counter;

        counter = counter + step;
        i++;
    }

    return Point;
}

void printSimulation(Point *Point, int length, FILE* datei)
{
    for(int i=0; i<length; i++)
    {
        //fprintf(datei, "%.2f ; %.2f ; %.2f\n", Point[i].counter, Point[i].x, Point[i].xDot);
        printf("t=%.3f[s] ; x=%.3f[m] ; x_punkt=%.3f[m/s]\n", Point[i].counter, Point[i].x, Point[i].xDot);
    }
}

int main()
{
    double x=0, xDot=0, xDotDot=0, x_0=0;
    double step=0.1, counter=0, time=2;
    double timeTol=0.05;
    double dauerT=0, lastCount=0;

    Point *PhasePtr;

    //Datei für Results öffnen
    FILE* datei = fopen("selbsterregte Schwingung_results.csv", "a");

    if(datei==NULL){
        printf("Fehler bei Dateizugriff");
        return 1;
    }

    //Parameter eingeben
    printf("Simulationsparamter eingeben \nDämpfungsfaktor b:");
    scanf("%lf", &const_b);
    printf("Startauslenkung x,0=");
    scanf("%lf", &x_0);
    printf("Simulationsdauer I:");
    scanf("%lf", &time);
    fflush(stdin);
    int length=time/step;

    //Simulation läuft
    PhasePtr=runSimulation(time, x_0, step);

    //Ergebnisse auf Bildschirm und in Datei gespeichert
    printSimulation(PhasePtr, length, datei);

    fclose(datei);
    return 0;
}

this is the wrong output (obviously the long numbers and the nulls in between are the wrong ones)

t=1.600[s] ; x=-0.502[m] ; x_punkt=-0.975[m/s]
t=1.700[s] ; x=-0.595[m] ; x_punkt=-0.928[m/s]
t=1.800[s] ; x=-0.682[m] ; x_punkt=-0.875[m/s]
t=1.900[s] ; x=-0.764[m] ; x_punkt=-0.820[m/s]
t=2.000[s] ; x=-0.840[m] ; x_punkt=-0.761[m/s]
t=2.100[s] ; x=-0.911[m] ; x_punkt=-0.701[m/s]
t=179538685518702200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000[s] ; x=0.000[m] ; x_punkt=11186857329615961000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=179538516283209850000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000[s] ; x=195426269015847380000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000[m] ; x_punkt=0.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=0.000[s] ; x=0.000[m] ; x_punkt=0.000[m/s]
t=78973501660828132000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000[s] ; x=0.000[m] ; x_punkt=14621964126845871000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.000[m/s]
t=3.900[s] ; x=-1.096[m] ; x_punkt=0.779[m/s]
t=4.000[s] ; x=-1.005[m] ; x_punkt=0.911[m/s]
t=4.100[s] ; x=-0.903[m] ; x_punkt=1.020[m/s]
t=4.200[s] ; x=-0.792[m] ; x_punkt=1.108[m/s]
t=4.300[s] ; x=-0.675[m] ; x_punkt=1.177[m/s]
t=4.400[s] ; x=-0.552[m] ; x_punkt=
and so on

Please show some example input you give the program. Btw, you have a lot of unused variables in the program. Try to strip all those away when making a minimal reproducible example. — Ted Lyngmo
– Ted Lyngmo, Commented Jul 14, 2021 at 22:09
please post a bit of the csv file. And maybe translate some of the prompts — arfneto
– arfneto, Commented Jul 14, 2021 at 22:41
Point *Point= malloc(time/step*sizeof(Point));?!?! Do you know which Point is used by sizeof(Point)? @MikeCAT says it's confusing, and that's true. But it's also quite likely downright wrong because the wrong Point is being used. If sizeof() in this case returns the size of the pointer variable Point and not the structure type Point. Do you know? If you don't, change the code. And if you do know, change the code anyway because it is confusing. — Andrew Henle
– Andrew Henle, Commented Jul 14, 2021 at 23:57

Ted Lyngmo · Accepted Answer · 2021-07-14 22:14:27Z

1

Don't name your pointer variable the same as the type Point.

Example:

Point* runSimulation(double time, double x_0, double step) {
    double x = x_0;
    double xDot = 0;
    double xDotDot = 0;
    double counter = 0;
    int i = 0;

    // is this formula really correct?
    Point* pnt = malloc(time / step * sizeof(Point));

    while(counter < time) {
        xDotDot = DGL(x, xDot);
        xDot = xDot + xDotDot * step;
        x = x + xDot * step;

        pnt[i].x = x;
        pnt[i].xDot = xDot;
        pnt[i].counter = counter;

        counter = counter + step;
        i++;
    }

    return pnt;
}

You should also do free(PhasePtr); in main to free the memory after you're done.

answered Jul 14, 2021 at 22:14

Ted Lyngmo

124k7 gold badges93 silver badges155 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

chux · Accepted Answer · 2021-07-14 22:40:33Z

1

At least these problems:

Point *Point= malloc(time/step*sizeof(Point)); is dodgy as it can under allocate due to fraction truncation.

In general, better to use integer math to find allocation needs and use the same to iterate the loop.

Point *Point= malloc(time/step*sizeof(Point)) muddies the water: Is that size of the type or pointer? Use different names to be clear.

//                            Pass in length---v
Point *runSimulation(double time, double x_0, int length)
{
    double step = time/length;
    double x=x_0;
    double xDot=0;
    double xDotDot=0;
    double counter=0;
    int i=0;

    // Point *Point= malloc(length*sizeof(Point));
    Point *P = malloc(length * sizeof *P);

    // while(counter<time)
    for (i=0; i<length; i++) {
        xDotDot = DGL(x, xDot);
        xDot = xDot+xDotDot*step;
        x = x+xDot*step;

        // P, not Point
        P[i].x = x;
        P[i].xDot = xDot;
        P[i].counter = counter;

        counter = counter + step;
        // i++;
    }

    return P; // P
}

and call

PhasePtr = runSimulation(time, x_0, length);

"%g"

Tip: Use "%.3g" to print double instead of %.3f as it handles large and wee values better.

edited Jul 14, 2021 at 22:40

answered Jul 14, 2021 at 22:16

chux

158k17 gold badges160 silver badges311 bronze badges

4 Comments

Ted Lyngmo Over a year ago

The problem with the variable Point is however what makes the program really funky. I'm trying to understand why myself. Both gcc and clang interprets it the same way so I'm guessing it's not a compiler bug.

Ted Lyngmo Over a year ago

I've used the program without getting out of bounds with OP:s existing formula but just to be safe, I used yours instead. Same issues as before - until the variable is renamed.

chux Over a year ago

@TedLyngmo Yep, multiple issues. UV

Ted Lyngmo Over a year ago

Yes, indeed. I'm glad for -ggdb -fsanitize=address,undefined :-)

Mike Stallone · Accepted Answer · 2021-07-15 02:34:51Z

I can see a decent amount of issues in this code which could be causing this problem:

names duplicated everywhere in differing contexts:

You can confuse the compiler (and yourself, realistically) if you name your struct the same thing as your type. When you type Point, is it referring to the struct type or the struct? It's up to the compiler, and it might be getting confused and using the wrong one. This is not the only issue of this in the code, but it is the worst offender

It's not clear to me what math operations you're trying to do with your code, and even less so to the compiler:

double xDotDot = -const_b/mxDot-const_k/mx+p/m*sgn;

With the above statement, do you want the compiler to do (xDot*const_b)/m? Because that's how it will be evaluated

Malloc with doubles

Point* pnt = malloc(time / step * sizeof(Point));

this really should not be done. Convert this to the correct type first, ie. uint32_t
since you're not explicitly determining type, the compiler could assume that you are doing math with uint32_t values, in which case 0.1 will be converted to 0, and your equation will be interpreted as the below, which will obviously cause issues with your program:

Point* pnt = malloc(time/0* sizeof(Point));

You shouldn't malloc in a function:

malloc the size of your pointer-array in the main, pass the pointer to said array into your function. You then won't have to deal with any of the clunkiness of returning a struct-pointer, and it's good practice for malloc for the future; you want to make it as obvious as possible that you've allocated memory, so you don't run into a scenario where your code continues to allocated memory forever until there's no space left on your processor

Collectives™ on Stack Overflow

wrong output of programm, using pointers to an array of structs

3 Answers 3

Comments

4 Comments

1 Comment

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

4 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Related