VSCode exiting C code with code=3221225477 - c

Question

I wrote the C program below using VSCode on my old 64 bit Windows 10 Enterprise computer. It worked perfectly when I ran it on there, and it also works perfectly when I run it on this online C compiler. However, when I try to run it on VSCode on my new 64 bit Windows 11 Home computer, it exits with code=3221225477. Does anyone know what I should do about this? Thanks.
What I've tried so far:
I've tried writing programs to test each of the functions in it and they all ran perfectly fine on VSCode on my new computer; I'm only getting problems when I run the entire program
Because my new computer has Norton installed on it, it likes to think that some of my C programs are viruses and stops them from being executed. However, I made a folder that I have told it not to interfere with and copied my program there. I still got code=3221225477 when I ran it.
/*
File name : triangulation.c
Author : kene02
Last modified : 20/12/2021
License : All rights reserved
Description:
Uses triangulation to find where a point is.
*/
#define _USE_MATH_DEFINES
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
// Function declarations
float distance_between(float *point_1, float *point_2);
float find_gradient(float *point_1, float *point_2);
char *bearing(float *point_1, float *point_2);
float *triangulate(float *a, float *b, float *c, float *d);
int main()
{
// Allocating memory for coordinates
float *point_a = (float *)malloc(2*sizeof(float));
float *point_b = (float *)malloc(2*sizeof(float));
float *point_c = (float *)malloc(2*sizeof(float));
float *point_d = (float *)malloc(2*sizeof(float));
point_a[0] = 328;
point_a[1] = -1445;
point_b[0] = 325;
point_b[1] = -1455;
point_c[0] = 286;
point_c[1] = -1567;
point_d[0] = 292;
point_d[1] = -1575;
// Print coordinates
printf("\nA(%.1f, %.1f)\t", point_a[0], point_a[1]);
printf("B(%.1f, %.1f)\n", point_b[0], point_b[1]);
printf("C(%.1f, %.1f)\t", point_c[0], point_c[1]);
printf("D(%.1f, %.1f)\n\n", point_d[0], point_d[1]);
// Evaluate point of intersection
float *point_x = triangulate(point_a, point_b, point_c, point_d);
// Evaluate bearings
char *bng_ba = bearing(point_b, point_a);
char *bng_dc = bearing(point_d, point_c);
char *bng_xa = bearing(point_x, point_a);
char *bng_xc = bearing(point_x, point_c);
if (strcmp(bng_ba, bng_xa) != 0 || strcmp(bng_dc, bng_xc) != 0) {
printf("Lines do not intersect.\n\n");
} else {
float length_xa = distance_between(point_x, point_a);
float length_xc = distance_between(point_x, point_c);
printf("Point of intersection\t\t\t: ");
printf("X(%.1f, %.1f)\n", point_x[0], point_x[1]);
printf("Distance and bearing of X from A\t: ");
printf("%.1f units, %s\n", length_xa, bng_xa);
printf("Distance and bearing of X from C\t: ");
printf("%.1f units, %s\n\n", length_xc, bng_xc);
}
return 0;
}
/**
* #brief distance_between function: finds the distance between two points.
*
* #param point_1 the (x, y) coordinates of the 1st point
* #param point_2 the (x, y) coordinates of the 2nd point
* #return the distance between the two points
*/
float distance_between(float *point_1, float *point_2)
{
float x_diff = point_2[0] - point_1[0];
float y_diff = point_2[1] - point_1[1];
float distance = sqrt(pow(x_diff, 2) + pow(y_diff, 2));
return distance;
}
/**
* #brief find_gradient function: finds the gradient of the line between two
* points.
*
* #param point_1 the (x, y) coordinates of the 1st point
* #param point_2 the (x, y) coordinates of the 2nd point
* #return the gradient of the line between the two points
*/
float find_gradient(float *point_1, float *point_2)
{
float x_diff = point_2[0] - point_1[0];
float y_diff = point_2[1] - point_1[1];
float gradient = y_diff/x_diff;
return gradient;
}
/**
* #brief traingulate function: finds the point of intersection of the line
* passing through points A & B and the line passing though points C & D.
*
* #param a the coordinates of point A
* #param b the coordinates of point B
* #param c the coordinates of point C
* #param d the coordinates of point D
* #return the point at which the lines intersect
*/
float *triangulate(float *a, float *b, float *c, float *d)
{
float *intersect = (float *)malloc(2*sizeof(float));
float g1 = find_gradient(a, b);
float g2 = find_gradient(c, d);
if (a[0] == b[0]) {
intersect[0] = a[0];
intersect[1] = c[1] + (a[0]-c[0])*g2;
} else if (c[0] == d[0]) {
intersect[0] = c[0];
intersect[1] = a[1] - (a[0]-c[0])*g1;
} else {
intersect[0] = ((a[1]-c[1]) + c[0]*g2 - a[0]*g1)/(g2-g1);
intersect[1] = (a[1]*g2 - c[1]*g1 + (c[0]-a[0])*g2*g1)/(g2-g1);
}
return intersect;
}
/**
* #brief bearing function: finds the compass bearing of point_1 from point_2
*
* #param point_1 the coordinates of the point to find the compass bearing of
* relative to point_2
* #param point_2 the coordinates of the reference point from which the compass
* bearing of point_1 will be measured
* #return the compass bearing of point_1 from point_2
*/
char *bearing(float *point_1, float *point_2)
{
const float RAD_DEG_RATIO = 180/M_PI;
float x_diff = point_1[0] - point_2[0];
float y_diff = point_1[1] - point_2[1];
float gradient = y_diff/x_diff;
char *bearing = (char *)malloc(7*sizeof(char));
if (x_diff == 0 && y_diff > 0) {
sprintf(bearing, "N");
} else if (x_diff == 0 && y_diff < 0) {
sprintf(bearing, "S");
} else if (x_diff > 0 && y_diff == 0) {
sprintf(bearing, "E");
} else if (x_diff < 0 && y_diff == 0) {
sprintf(bearing, "W");
} else if (x_diff > 0 && y_diff > 0) {
float angle = 90 - RAD_DEG_RATIO*atan(gradient);
sprintf(bearing, "N %.2f E", angle);
} else if (x_diff < 0 && y_diff > 0) {
float angle = 90 + RAD_DEG_RATIO*atan(gradient);
sprintf(bearing, "N %.2f W", angle);
} else if (x_diff < 0 && y_diff < 0) {
float angle = 90 - RAD_DEG_RATIO*atan(gradient);
sprintf(bearing, "S %.2f W", angle);
} else if (x_diff > 0 && y_diff < 0) {
float angle = 90 + RAD_DEG_RATIO*atan(gradient);
sprintf(bearing, "S %.2f E", angle);
}
return bearing;
}

Answer 1

3221225477 decimal is gibberish. Translated to hex you get 0xC0000005, which is Windows' error code for access violation (also known as "seg fault"). The most likely cause is array out of bounds access.
The bug is here: malloc(7*sizeof(char)); creates too little memory to contain what your sprintf might produce. This can only hold 6 characters + the mandatory null terminator. Memory is cheap, so change this for something with margins like:
char *bearing = malloc(20);
Why you keep using malloc all over the place to allocate tiny amounts of memory, I have no idea. All you achieve with that is to slow down everything and create potential for memory leaks.
It's better practice to have your function work with caller allocated memory whenever possible. It is not good design to mix up memory allocation and the actual algorithm in the same function.