D2L Bright space After completing this assignment students should be able to wri
ID: 3850005 • Letter: D
Question
D2L Bright space After completing this assignment students should be able to write C modules/libraries that use: structs memory allocation header files In addition to the Clanguage programming constructs already in their toolbox. During this class exercise we're going to construct some simple functionality for a geographic information system (GIS).x Part One construct and test two modules: one for a String and a Point2D. r each, build a definition and functions to access and manage instances. The intent is that user code does not "touch" the data structure, but that the module code does that. In the case of String you can rely on the existing String library for access and management, however you will need to define a String as a char and write the mallocString and freeString functions. The Point2D module will require not only the mallocPoint2D and freePoint2D functions but the ability to set and get values as well as calculate the distance between two points. Your modules should also be able to read and write individual instances from/to a text file.Explanation / Answer
Part2Driver.c
#include<stdio.h>
#include"Point2D.h"
#include"String.h"
#include"LabelPoint2D.h"
#include"Point2DNode.h"
#include"Line2D.h"
int main() {
/* Label Point test variables */
Point2D *p1, *p2, *p3;
String s1, s2, s3;
double x1, y1, x2, y2;
int xErr, yErr;
int status;
LabelPoint2D* pLP2D;
LabelPoint2D* pLP2Dread;
FILE* pfile;
/* Line Test Variables */
int err;
double x, y;
Point2D* pPt2D1;
Point2D* pPt2D2;
Point2D* testPt2D;
Point2DNode *pPt2DN, *pPt2DN2, *testPt2DN, *testPt2DN2;
LabelPoint2D *testLP2D, *testLP2D2;
String str, testStr;
Line2D *pLine2D, *pLine2D2;
/* Test LabelPoint2D Functions */
printf("===============LabelPoint2D TEST 1=============== ");
status = 0;
p1 = createPoint2D(1.0, 2.0);
s1 = createString("Test First String");
pLP2D = createLabelPoint2D(s1, p1);
/*Getting the String and Point used to create pLP2D*/
p2 = getPoint(pLP2D);
s2 = getLabel(pLP2D);
xErr = 0;
yErr = 0;
x1 = getXPoint2D(p2, &xErr);
y1 = getYPoint2D(p2, &yErr);
printf("Label pLP2D's String: '%s' ", s2);
printf("Label pLP2D's Point2D: (%0.2f, %0.2f) ", x1, y1);
if(xErr == 1 || yErr == 1) {
printf("There was an error getting either the x or y of the Point2D in pLD2D ");
}
/* Second test using LabelPoint2D*/
printf("===============LabelPoint2D TEST 2=============== ");
p3 = createPoint2D(3.5, 7.2);
s3 = createString("Test Second String");
status = setLabel(pLP2D, s3);
if(status == 1) {
printf("Something went wrong setting string of pLP2D");
}
status = setPoint(pLP2D, p3);
if(status == 1) {
printf("Something went wrong setting point of pLP2D");
}
/*Get the modified Point2D and String of pLP2D to check if changed*/
p2 = getPoint(pLP2D);
s2 = getLabel(pLP2D);
xErr = 0;
yErr = 0;
x1 = getXPoint2D(p2, &xErr);
y1 = getYPoint2D(p2, &yErr);
printf("Label pLP2D's Modified String: '%s' ", s2);
printf("Label pLP2D's Modified Point2D (%0.2f, %0.2f) ", x1, y1);
if(xErr == 1 || yErr == 1) {
printf("D'oh! ");
}
/* Second test using LabelPoint2D File IO*/
printf("===============LabelPoint2D TEST 3=============== ");
p3 = createPoint2D(4.5, 6.0);
s3 = createString("Test Third String -Output String");
status = setLabel(pLP2D, s3);
if(status == 1) {
printf("Something went wrong setting string of pLP2D");
}
status = setPoint(pLP2D, p3);
if(status == 1) {
printf("Something went wrong setting point of pLP2D");
}
/*Opening file for writing*/
pfile = fopen("LabelPoint.txt", "w");
status = fputLabelPoint2D(pfile, pLP2D);
if(status == 1) {
printf("Something went wrong printing pLP2D to file LabelPoint.txt");
}
fclose(pfile);
/*Read from file*/
pfile = fopen("LabelPoint.txt", "r");
pLP2Dread = fgetLabelPoint2D(pfile, &status);
if(status == 1) {
printf("Something went wrong reading from file LabelPoint.txt");
}
fclose(pfile);
p2 = getPoint(pLP2Dread);
s2 = getLabel(pLP2Dread);
xErr = 0;
yErr = 0;
x1 = getXPoint2D(p2, &xErr);
y1 = getYPoint2D(p2, &yErr);
printf("THE FOLLOWING WAS READ FROM FILE LabelPoint.txt ");
printf("Label pLP2Dread's Read in String: '%s' ", s2);
printf("Label pLP2Dread's Read in Point2D (%0.2f, %0.2f) ", x1, y1);
if(xErr == 1 || yErr == 1) {
printf("There was an error getting x and y from pLP2Dread ");
}
pLP2Dread = freeLabelPoint2D(pLP2Dread);
if(pLP2Dread == (LabelPoint2D*)NULL){
printf("Free successful ");
} else {
printf("Free not successful ");
}
/* Test Line2D Functions */
printf("==================Line2D TEST 1================== ");
err = 0;
xErr = 0;
yErr = 0;
pPt2D1 = createPoint2D(1.0, 2.0);
pPt2D2 = createPoint2D(6.2, 3.5);
/*Create pPt2DN which is a pPt2D Node*/
pPt2DN = createPoint2DNode(pPt2D1);
testStr = "Line2D Test String";
pLP2D = createLabelPoint2D(testStr, createPoint2D(99.0, 100.0));
/*Create first Line */
pLine2D = createLine2D(pLP2D, pPt2DN);
if(pLine2D == (Line2D*)NULL) {
printf("Line2D of pLine2D creation unsuccessful. ");
} else {
printf("Line2D, pLine2D creation was successful. ");
}
/*Add Node to Line*/
pPt2DN2 = createPoint2DNode(pPt2D2);
err = addPtLine2D(pLine2D, pPt2DN2);
if(err == 1) {
printf("Something went wrong in adding a node to pLine2D. ");
}
else {
printf("Node pPt2D2 successfully added to pLine2D. ");
}
/*Testing Getters for Line2D*/
pPt2DN = getHeadLine2D(pLine2D, &err);
if(err == 1) {
printf("Something went wrong getting the Head of pLine2D. ");
}
pLP2D = getLabelLine2D(pLine2D, &err);
if(err == 1) {
printf("Something went wrong getting the Label of pLine2D. ");
}
/*Print our findings*/
p2 = getPoint(pLP2D);
s2 = getLabel(pLP2D);
xErr = 0;
yErr = 0;
x1 = getXPoint2D(p2, &xErr);
y1 = getYPoint2D(p2, &yErr);
printf("The String of pLine2D's Label pLP2D: '%s' ", s2);
printf("The Point2D of pLine2D's Label pLP2D (%0.2f, %0.2f) ", x1, y1);
if(xErr == 1 || yErr == 1) {
printf("There was an error getting x and y from Line2D's pLP2D ");
}
pPt2D1 = getNodePoint(pPt2DN, &err);
if(err == 1) {
printf("Something went wrong getting the Point of pLine2D's head Node. ");
}
xErr = 0;
yErr = 0;
x1 = getXPoint2D(pPt2D1, &xErr);
y1 = getYPoint2D(pPt2D1, &yErr);
printf("The Point2D of pLine2D's Head Node (%0.2f, %0.2f) ", x1, y1);
if(xErr == 1 || yErr == 1) {
printf("There was an error getting x and y from Line2D's head Node Point ");
}
pPt2DN = getNextNode(pPt2DN, &err);
if(err == 1) {
printf("Something went wrong getting Next Node of pLine2D's head Node. ");
}
pPt2D1 = getNodePoint(pPt2DN, &err);
if(err == 1) {
printf("Something went wrong getting the Point of pLine2D's Second Node. ");
}
xErr = 0;
yErr = 0;
x1 = getXPoint2D(pPt2D1, &xErr);
y1 = getYPoint2D(pPt2D1, &yErr);
printf("The Point2D of pLine2D's Second Node (%0.2f, %0.2f) ", x1, y1);
if(xErr == 1 || yErr == 1) {
printf("There was an error getting x and y from Line2D's S Node Point ");
}
/*Testing if Setters Work*/
printf("==================Line2D TEST 2================== ");
testPt2DN = createPoint2DNode(createPoint2D(5.5, 2.1));
status = addPtLine2D(pLine2D, testPt2DN);
if(status == 1) {
printf("Could not add point to line ");
} else {
printf("Point added successfully to line ");
}
status = setHeadLine2D(pLine2D, testPt2DN);
if(status == 1) {
printf("Could not set head ");
} else {
printf("Head set successfully ");
}
pLP2D = createLabelPoint2D("Label Test Setters", createPoint2D(0.3, 5.2));
status = setLabelLine2D(pLine2D, pLP2D);
if(status == 1) {
printf("Could not set label point ");
} else {
printf("Label point set successfully ");
}
/*The following is all for printing our modified Line2D*/
pPt2DN = getHeadLine2D(pLine2D, &err);
if(err == 1) {
printf("Something went wrong getting the Head of pLine2D. ");
}
pLP2D = getLabelLine2D(pLine2D, &err);
if(err == 1) {
printf("Something went wrong getting the Label of pLine2D. ");
}
p2 = getPoint(pLP2D);
s2 = getLabel(pLP2D);
xErr = 0;
yErr = 0;
x1 = getXPoint2D(p2, &xErr);
y1 = getYPoint2D(p2, &yErr);
printf("The String of pLine2D's Modified Label pLP2D: '%s' ", s2);
printf("The Point2D of pLine2D's Modified Label pLP2D (%0.2f, %0.2f) ", x1, y1);
if(xErr == 1 || yErr == 1) {
printf("There was an error getting x and y from Line2D's pLP2D ");
}
pPt2D1 = getNodePoint(pPt2DN, &err);
if(err == 1) {
printf("Something went wrong getting the Point of pLine2D's head Node. ");
}
xErr = 0;
yErr = 0;
x1 = getXPoint2D(pPt2D1, &xErr);
y1 = getYPoint2D(pPt2D1, &yErr);
printf("The Point2D of pLine2D's Modified Head Node (%0.2f, %0.2f) ", x1, y1);
if(xErr == 1 || yErr == 1) {
printf("There was an error getting x and y from Line2D's head Node Point ");
}
/*Testing file i.o*/
printf("==================Line2D TEST 3================== ");
pfile = fopen("testFile.txt", "w");
printf("Error Status for writing Line2D to file (0=success 1=fail): %d ", fputLine2D(pfile, pLine2D));
fclose(pfile);
/*Reading from File*/
pfile = fopen("testFile.txt", "r");
pLine2D2 = fgetLine2D(pfile, &err);
printf("Error Status for reading Line2D from file (0=success 1=fail): %d ", err);
fclose(pfile);
/*The following is all for printing our modified Line2D*/
pPt2DN = getHeadLine2D(pLine2D2, &err);
if(err == 1) {
printf("Something went wrong getting the Head of pLine2D. ");
}
pLP2D = getLabelLine2D(pLine2D2, &err);
if(err == 1) {
printf("Something went wrong getting the Label of pLine2D. ");
}
p2 = getPoint(pLP2D);
s2 = getLabel(pLP2D);
xErr = 0;
yErr = 0;
x1 = getXPoint2D(p2, &xErr);
y1 = getYPoint2D(p2, &yErr);
printf("The String of pLine2D2's Read In Label pLP2D: '%s' ", s2);
printf("The Point2D of pLine2D2's Read In Label pLP2D (%0.2f, %0.2f) ", x1, y1);
if(xErr == 1 || yErr == 1) {
printf("There was an error getting x and y from pLine2D2's pLP2D ");
}
pPt2D1 = getNodePoint(pPt2DN, &err);
if(err == 1) {
printf("Something went wrong getting the Point of pLine2D2's head Node. ");
}
xErr = 0;
yErr = 0;
x1 = getXPoint2D(pPt2D1, &xErr);
y1 = getYPoint2D(pPt2D1, &yErr);
printf("The Point2D of pLine2D2's Read In Head Node (%0.2f, %0.2f) ", x1, y1);
if(xErr == 1 || yErr == 1) {
printf("There was an error getting x and y from pLine2D2's head Node Point ");
}
/*Freeing our variables*/
printf("==================Line2D TEST 4================== ");
pLine2D2 = freeLine2D(pLine2D2);
if(pLine2D2 == (Line2D*)NULL) {
printf("pLine2D2 was successfully free'd. ");
}
else {
printf("pLine2D2 was not successfully free'd. ");
}
printf("=================TEST COMPLETE=================== ");
return 0;
}
LabelPoint2DMain.c
#include<stdio.h>
#include"Point2D.h"
#include"String.h"
#include"LabelPoint2D.h"
int main() {
Point2D *p1, *p2, *p3;
String s1, s2, s3;
double x1, y1, x2, y2;
int* pXErr;
int* pYErr;
int xErr, yErr;
int status;
LabelPoint2D* pLP2D;
LabelPoint2D* read;
FILE* pfile;
status = 0;
p1 = createPoint2D(1.0, 2.0);
s1 = createString("Test (Please don't blow up)");
pLP2D = createLabelPoint2D(s1, p1);
p2 = getPoint(pLP2D);
s2 = getLabel(pLP2D);
xErr = 0;
yErr = 0;
pXErr = &xErr;
pYErr = &yErr;
x1 = getXPoint2D(p2, pXErr);
y1 = getYPoint2D(p2, pYErr);
printf("Label: '%s' ", s2);
printf("(%0.2f, %0.2f) ", x1, y1);
if(xErr == 1 || yErr == 1) {
printf("D'oh! ");
}
p3 = createPoint2D(3.5, 7.2);
s3 = createString("Test Numero 2 (Please don't blow up)");
status = setLabel(pLP2D, s3);
if(status == 1) {
printf("Something went wrong setting string");
}
status = setPoint(pLP2D, p3);
if(status == 1) {
printf("Something went wrong setting point");
}
p2 = getPoint(pLP2D);
s2 = getLabel(pLP2D);
xErr = 0;
yErr = 0;
pXErr = &xErr;
pYErr = &yErr;
x1 = getXPoint2D(p2, pXErr);
y1 = getYPoint2D(p2, pYErr);
printf("Label: '%s' ", s2);
printf("(%0.2f, %0.2f) ", x1, y1);
if(xErr == 1 || yErr == 1) {
printf("D'oh! ");
}
p3 = createPoint2D(4.2, 6.9);
s3 = createString("Test Numero 3 (Please, please don't blow up)");
status = setLabel(pLP2D, s3);
if(status == 1) {
printf("Something went wrong setting string");
}
status = setPoint(pLP2D, p3);
if(status == 1) {
printf("Something went wrong setting point");
}
pfile = fopen("LabelPoint.txt", "w");
status = fputLabelPoint2D(pfile, pLP2D);
if(status == 1) {
printf("Something went wrong printing to file");
}
fclose(pfile);
pfile = fopen("LabelPoint.txt", "r");
read = fgetLabelPoint2D(pfile, &status);
if(status == 1) {
printf("Something went wrong reading from file");
}
fclose(pfile);
p2 = getPoint(read);
s2 = getLabel(read);
xErr = 0;
yErr = 0;
pXErr = &xErr;
pYErr = &yErr;
x1 = getXPoint2D(p2, pXErr);
y1 = getYPoint2D(p2, pYErr);
printf("READ FROM FILE ");
printf("Label: '%s' ", s2);
printf("(%0.2f, %0.2f) ", x1, y1);
if(xErr == 1 || yErr == 1) {
printf("D'oh! ");
}
read = freeLabelPoint2D(read);
if(read == (LabelPoint2D*)NULL){
printf("Free successful ");
} else {
printf("Free not successful ");
}
}
LabelPoint2D.c
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include"String.h"
#include"Point2D.h"
#include"LabelPoint2D.h"
LabelPoint2D* mallocLabelPoint2D(int sLength) {
LabelPoint2D* pLP2D;
pLP2D = (LabelPoint2D*)malloc(sizeof(LabelPoint2D));
pLP2D -> pPt2D = mallocPoint2D();
pLP2D -> str = mallocString(sLength);
return pLP2D;
}
LabelPoint2D* freeLabelPoint2D(LabelPoint2D* pLP2D) {
if(pLP2D -> str != (String)NULL){
pLP2D -> str = freeString(pLP2D -> str);
}
if(pLP2D -> pPt2D != (Point2D*)NULL) {
pLP2D -> pPt2D = freePoint2D(pLP2D -> pPt2D);
}
free(pLP2D);
return (LabelPoint2D*)NULL;
}
int fputLabelPoint2D(FILE* pfile, LabelPoint2D* pLP2D) {
String s;
Point2D* pP;
s = pLP2D -> str;
pP = pLP2D -> pPt2D;
if(fputString(pfile, s)) {
return 1;
}
if(fputPoint2D(pfile, pP)) {
return 1;
}
return 0;
}
LabelPoint2D* fgetLabelPoint2D(FILE* pfile, int* pErr) {
String s;
Point2D* pP;
s = fgetString(pfile, pErr);
if(*pErr == 1) {
return (LabelPoint2D*)NULL;
}
pP = fgetPoint2D(pfile, pErr);
if(*pErr == 1) {
return (LabelPoint2D*)NULL;
}
return createLabelPoint2D(s, pP);
}
LabelPoint2D* createLabelPoint2D(String str, Point2D* pPt2D) {
LabelPoint2D* pLP2D;
int status;
int len;
len = strlen(str);
pLP2D = mallocLabelPoint2D(len);
if(setLabel(pLP2D, str)) {
return (LabelPoint2D*)NULL;
}
if(setPoint(pLP2D, pPt2D)) {
return (LabelPoint2D*)NULL;
}
return pLP2D;
}
String getLabel(LabelPoint2D* pLP2D) {
return pLP2D -> str;
}
Point2D* getPoint(LabelPoint2D* pLP2D) {
return pLP2D -> pPt2D;
}
int setLabel(LabelPoint2D* pLP2D, String inStr) {
if(pLP2D == (LabelPoint2D*)NULL){
return 1;
} else {
pLP2D -> str = inStr;
return 0;
}
}
int setPoint(LabelPoint2D* pLP2D, Point2D* pInPt2D) {
if(pLP2D == (LabelPoint2D*)NULL){
return 1;
} else {
pLP2D -> pPt2D = pInPt2D;
return 0;
}
}
LabelPoint2D.h
typedef struct {
Point2D* pPt2D;
String str;
} LabelPoint2D;
LabelPoint2D* mallocLabelPoint2D(int sLength);
LabelPoint2D* freeLabelPoint2D(LabelPoint2D* pLP2D);
int fputLabelPoint2D(FILE* pfile, LabelPoint2D* pLP2D);
LabelPoint2D* fgetLabelPoint2D(FILE* pfile, int* pErr);
LabelPoint2D* createLabelPoint2D(String str, Point2D* pPT2D);
String getLabel(LabelPoint2D* pLP2D);
Point2D* getPoint(LabelPoint2D* pLP2D);
int setLabel(LabelPoint2D* pLP2D, String inStr);
int setPoint(LabelPoint2D* pLP2D, Point2D* pInPt2D);
Line2D.c
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include"Point2D.h"
#include"String.h"
#include"LabelPoint2D.h"
#include"Point2DNode.h"
#include"Line2D.h"
Line2D* mallocLine2D(int sLength) {
Line2D* pLine2D;
pLine2D = (Line2D*)malloc(sizeof(Line2D));
pLine2D->lbl = mallocLabelPoint2D(sLength);
pLine2D->pHead = mallocPoint2DNode();
return pLine2D;
}
Line2D* freeLine2D(Line2D* pLine2D) {
Point2DNode* pTempNode;
Point2DNode* pWorkNode;
pWorkNode = pLine2D->pHead;
while(pWorkNode != (Point2DNode*)NULL) {
pTempNode = pWorkNode->nextNode;
freePoint2DNode(pWorkNode);
pWorkNode = pTempNode;
}
return (Line2D*)NULL;
}
Line2D* createLine2D(LabelPoint2D* pLP2D, Point2DNode* pPt2DNode) {
Line2D* pLine2D;
int len;
len = (strlen(pLP2D->str));
pLine2D = mallocLine2D(len);
if(pLine2D == (Line2D*)NULL) {
return pLine2D;
}
setHeadLine2D(pLine2D, pPt2DNode);
setLabelLine2D(pLine2D, pLP2D);
return pLine2D;
}
int addPtLine2D(Line2D* pLine2D, Point2DNode* pPt2DNode) {
Point2DNode* pWorking;
if(pLine2D == (Line2D*)NULL || pPt2DNode == (Point2DNode*)NULL) {
return 1;
}
pWorking = pLine2D->pHead;
while(pWorking->nextNode != (Point2DNode*)NULL) {
pWorking = pWorking->nextNode;
}
pWorking->nextNode = pPt2DNode;
return 0;
}
Point2DNode* getHeadLine2D(Line2D* pLine2D, int* pErr) {
if(pLine2D == (Line2D*)NULL) {
*pErr = 1;
return (Point2DNode*)NULL;
}
return pLine2D->pHead;
}
int setHeadLine2D(Line2D* pLine2D, Point2DNode* pPt2DNode) {
if(pLine2D == (Line2D*)NULL) {
return 1;
}
pLine2D->pHead = pPt2DNode;
return 0;
}
LabelPoint2D* getLabelLine2D(Line2D* pLine2D, int* pErr) {
if(pLine2D == (Line2D*)NULL) {
*pErr = 1;
return (LabelPoint2D*)NULL;
}
return pLine2D->lbl;
}
int setLabelLine2D(Line2D* pLine2D, LabelPoint2D* pLP2D) {
if(pLine2D == (Line2D*)NULL) {
return 1;
}
pLine2D->lbl = pLP2D;
return 0;
}
Line2D* fgetLine2D(FILE* pfile, int* pErr) {
Line2D *pLine2D;
Point2D* pPt2D;
LabelPoint2D* pLP2D;
Point2DNode* pP2DN;
double x, y;
int status;
if(pfile == (FILE*)NULL) {
*pErr = 1;
}
pLP2D = fgetLabelPoint2D(pfile, pErr);
status = fscanf(pfile, "%lf %lf", &x, &y);
if(status < 2) {
*pErr = 1;
}
pPt2D = createPoint2D(x, y);
pP2DN = createPoint2DNode(pPt2D);
pLine2D = createLine2D(pLP2D, pP2DN);
status = fscanf(pfile, "%lf %lf", &x, &y);
while(status == 2) {
pPt2D = createPoint2D(x, y);
pP2DN = createPoint2DNode(pPt2D);
*pErr = addPtLine2D(pLine2D, pP2DN);
status = fscanf(pfile, "%lf %lf", &x, &y);
}
return pLine2D;
}
int fputLine2D(FILE* pfile, Line2D* pLine2D) {
Point2DNode* pPt2DN;
Point2D* pPt2DOut;
int status;
int* pXErr;
int* pYErr;
int err, xErr, yErr;
double x, y;
if(pfile == (FILE*)NULL || pLine2D == (Line2D*)NULL) {
return 1;
}
status = fputLabelPoint2D(pfile, pLine2D->lbl);
if(status == 1){
return 1;
}
pXErr = &xErr;
pYErr = &yErr;
err = 0;
pPt2DN = pLine2D->pHead;
while(pPt2DN != (Point2DNode*)NULL) {
xErr = 0;
yErr = 0;
x = getXPoint2D(getNodePoint(pPt2DN, &err), pXErr);
y = getYPoint2D(getNodePoint(pPt2DN, &err), pYErr);
if(xErr == 1 || yErr == 1 || err == 1) {
return 1;
}
fprintf(pfile, "%f", x);
fputc(' ', pfile);
fprintf(pfile, "%f", y);
status = fputc(' ', pfile);
if(status == EOF) {
return 1;
}
pPt2DN = pPt2DN->nextNode;
}
}
Line2D.h
typedef struct {
LabelPoint2D* lbl;
Point2DNode* pHead;
} Line2D;
Line2D* mallocLine2D(int sLength);
Line2D* freeLine2D(Line2D* pLine2D);
Line2D* createLine2D(LabelPoint2D* pLP2D, Point2DNode* pPt2DNode);
int addPtLine2D(Line2D* pLine2D, Point2DNode* pPt2DNode);
Point2DNode* getHeadLine2D(Line2D* pLine2D, int* pErr);
int setHeadLine2D(Line2D* pLine2D, Point2DNode* pPt2DNode);
LabelPoint2D* getLabelLine2D(Line2D* pLine2D, int* pErr);
int setLabelLine2D(Line2D* pLine2D, LabelPoint2D* pLP2D);
Line2D* fgetLine2D(FILE* pfile, int* pErr);
int fputLine2D(FILE* pfile, Line2D* pLine2D);
LabelPoint.txt
32$Test Third String -Output String
4.500000 6.000000
Related Questions
Navigate
Integrity-first tutoring: explanations and feedback only — we do not complete graded work. Learn more.