Probelm with struct and typedef [closed] - arrays

Question

Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
This question does not appear to be about programming within the scope defined in the help center.
Closed 2 years ago.
Improve this question
I have to develop these 4 functions:
double distance (const point_t * a, const point_t * b)
double perimeter (const polygon_t * poly)
polygon_t create_triangle (point_t p0, double base, double height)
polygon_t create_square (point_t p0, double side)
The rest of the body of the program was already defined, but I can't figure out how to develop the last two functions, I would need someone to point me in the correct way.
My idea was to initialize the vector to then be able to make the square and the triangle from this but I have a difficulty in developing the function.
Can you help me?
P.S. I leave you below the delivery of the exercise and what I wrote myself:
"The program represents polygons of any number of sides using dynamic arrays of points. Triangles and squares, as notable polygons, can be conveniently constructed using the create_triangle() and create_square() shortcuts.
To construct other polygons it is necessary to manually populate the struct polygon_t through the appropriate assignments.
The main () constructs a triangle and a square and calculates the perimeter by calling the perimeter () function. The types polygon_t and point_t and the print_polygon () function are already implemented, they are located at the top of the source and are not editable.
Implement the following functions so that main() compiles and the program is complete:
the function polygon_t create_triangle (point_t p0, double base, double height) so that it returns by value a structure of type polygon_t suitably populated with the points that form an isosceles triangle having point of origin (bottom left point) in p0, base base length and height length height;
the function polygon_t create_square (point_t p0, double side) so that it returns by value a structure of the polygon_t type suitably populated with the points that form a square having a point of origin (bottom left point) in p0, and side length side ;
the function double perimeter (const polygon_t * poly) so that it calculates the perimeter of the polygon passed as an argument: use the distance() function between all the pairs of contiguous points and calculate the sum of the sides;
do not make assumptions about the number of sides: the data structure can represent any polygons;
the function double distance (const point_t * a, const point_t * b) which calculates the Euclidean distance between the two data points.
Example: the following program constructs a square with side 2 and a triangle with base 1 and height 0.86602; then calculate the perimeter of both."
#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <malloc.h>
char* readline();
char* ltrim(char*);
char* rtrim(char*);
double parse_double(char*);
typedef struct {
double x, y;
} point_t;
typedef struct {
size_t len;
point_t* points;
} polygon_t;
void print_polygon(const polygon_t* poly) {
size_t i;
printf("polygon_t(%ld)[", poly->len);
for (i = 0; i < poly->len; ++i) {
printf("(%g, %g) ", poly->points[i].x, poly->points[i].y);
}
printf("\b]");
}
/* da implementare */
double distance(const point_t* a, const point_t* b) {
float dist;
point_t* x = (point_t*) a;
point_t* y = (point_t*) b;
dist= sqrt((a->x - b->x) + (a->y - b->y));
return dist;
}
/* da implementare: deve usare distance() */
double perimeter(const polygon_t* poly) {
float per_tr= distance(poly->points, poly->points) + distance(poly->points, poly->points) +
distance(poly->points, poly->points);
float per_sq= distance(poly->points, poly->points) * 4;
return per_sq && per_tr;
}
/* da implementare */
polygon_t create_triangle(point_t p0, double base, double height) {
size_t i;
point_t p2;
polygon_t p1;
for (i = 0; i < p1.len; ++i)
p1.points[i].x= 0;
//base= distance(p1.points, p1.points);
//height= sqrt(pow(distance(p1.points, p1.points),2) - (pow(base,2)/4.0)) ;
p1.len[p1.points].x= 0;
return p1;
}
/* da implementare */
polygon_t create_square(point_t p0, double side) {
polygon_t p2;
size_t i;
p0.x = 0;
p0.y = 0;
for (i = 0; i < p2.len; ++i)
p2.points[i].x= 0;
}
p2.len[p2.points]= p2.points[side * 4,0];
// side= distance(p2.points, p2.points);
return p2;
}
int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");
double x = parse_double(ltrim(rtrim(readline())));
double y = parse_double(ltrim(rtrim(readline())));
double l = parse_double(ltrim(rtrim(readline())));
double b = parse_double(ltrim(rtrim(readline())));
double h = parse_double(ltrim(rtrim(readline())));
point_t origin;
polygon_t sq;
polygon_t tr;
origin.x = x; /* input riga #1 */
origin.y = y; /* input riga #2 */
sq = create_square(origin, l); /* input riga #3 */
tr = create_triangle(origin, b, h); /* input riga #4, #5 */
double p1 = perimeter(&sq);
double p2 = perimeter(&tr);
fprintf(fptr, "%.2f\n", p1); /* output riga #1 */
fprintf(fptr, "%.2f\n", p2); /* output riga #2 */
fclose(fptr);
return 0;
}
char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;
char* data = malloc(alloc_length);
while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);
if (!line) {
break;
}
data_length += strlen(cursor);
if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {
break;
}
alloc_length <<= 1;
data = realloc(data, alloc_length);
if (!data) {
data = '\0';
break;
}
}
if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';
data = realloc(data, data_length);
if (!data) {
data = '\0';
}
} else {
data = realloc(data, data_length + 1);
if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
}
return data;
}
char* ltrim(char* str) {
if (!str) {
return '\0';
}
if (!*str) {
return str;
}
while (*str != '\0' && isspace(*str)) {
str++;
}
return str;
}
char* rtrim(char* str) {
if (!str) {
return '\0';
}
if (!*str) {
return str;
}
char* end = str + strlen(str) - 1;
while (end >= str && isspace(*end)) {
end--;
}
*(end + 1) = '\0';
return str;
}
double parse_double(char* str) {
char* endptr;
double value = strtod(str, &endptr);
if (endptr == str || *endptr != '\0') {
exit(EXIT_FAILURE);
}
return value;
}

Answer 1

First need to fix distance:
#define pow2(a) ((a) * (a))
/* da implementare */
double distance(const point_t* a, const point_t* b) {
return sqrt(pow2(a->x - b->x) + pow2(a->y - b->y));
}
For perimeter, you need distance between all points and between last and first:
/* da implementare: deve usare distance() */
double perimeter(const polygon_t* poly) {
double res = 0;
for (int i = 0; i < poly->len - 1; i++) {
res += distance(&poly->points[i], &poly->points[i+1]);
}
res += distance(&poly->points[poly->len - 1], &poly->points[0]);
return res;
}
Then you need to malloc points array to store some point_t
For triangle:
|\
| \
h| \
|___\
p0 base
/* da implementare */
polygon_t create_triangle(point_t p0, double base, double height) {
polygon_t p;
p.len = 3;
p.points = malloc(3 * sizeof(point_t));
p.points[0] = p0;
p.points[1].x = p0.x + base;
p.points[1].y = p0.y;
p.points[2].x = p0.x;
p.points[2].y = p0.y + height;
return p;
}
For square
+------+
| |
| |
+------+
p0
/* da implementare */
polygon_t create_square(point_t p0, double side) {
polygon_t p;
p.len = 4;
p.points = malloc(4 * sizeof(point_t));
p.points[0] = p0;
p.points[1].x = p0.x;
p.points[1].y = p0.y + side;
p.points[2].x = p0.x + side;
p.points[2].y = p0.y + side;
p.points[3].x = p0.x + side;
p.points[3].y = p0.y;
return p;
}
You need to free p.points

Answer 2

Incorrect algorithms aside, the syntax of your implementation will not compile. All of the issues below can be identified in your compile output if it is set to show all warnings. Regardless of that, some of the mistakes result in errors, and failure to compile.
Issue 1 - uninitialized variables:
size_t i;
point_t p2;
polygon_t p1;
for (i = 0; i < p1.len; ++i)
^^^^^^ uninitialized
p1.len is not initialized at time of first use. It can be any value at run-time possibly invoking undefined behavior
And there are more potentially uninitialized variables :
Build Status (so.prj - Debug)
s0_15.c - 9 warnings
60, 20 warning: variable 'p1.len' may be ***uninitialized***when used here
57, 4 note: variable 'p1' is declared here
61, 7 warning: variable 'p1.points' may be ***uninitialized***when used here
57, 4 note: variable 'p1' is declared here
64, 14 warning: variable 'p1.points' may be ***uninitialized***when used here
57, 4 note: variable 'p1' is declared here
77, 21 warning: variable 'p2.len' may be ***uninitialized***when used here
72, 5 note: variable 'p2' is declared here
79, 8 warning: variable 'p2.points' may be ***uninitialized***when used here
72, 5 note: variable 'p2' is declared here
83, 24 warning: variable 'p2' may be ******uninitialized****** when used here
72, 5 note: variable 'p2' is declared here
Note: actual locations will vary in your output.
Issue 2 - missing curly brace and out of scope object:
polygon_t create_square(point_t p0, double side) {
polygon_t p2;//has block scope!
size_t i;
p0.x = 0;
p0.y = 0;
for (i = 0; i < p2.len; ++i)
p2.points[i].x= 0;
}
p2.len[p2.points]= p2.points[side * 4,0];
p2 is not defined here, only within {...} above.
It is because this statement:
for (i = 0; i < p2.len; ++i)
p2.points[i].x= 0;
}
Is missing a opening curly brace {
for (i = 0; i < p2.len; ++i)
{//add this curly
p2.points[i].x= 0;
}