Asg 1: List of Points

Objectives

Assignment

1. Using the data_t C++ code example discussed at length in class, write C++ code to define a point_t class (object) that will hold x- and y-coordinates of a 2D point.
2. Create two files: point.h that holds the object interface and point.cpp that holds the object implemantation.

Details

1. Your point_t object should provide the following:
   • Overloaded constructors:
     • point_t(double x=0.0, double y=0.0);
     • point_t(std::vector<double> c);
   • The big three:
     1. copy constructor (point_t(const point_t& rhs);)
     2. destructor (~point_t();), default ok (can comment this out)
     3. assignment operator (point_t operator=(const point_t& rhs);)
   • Input/output stream friend functions:
     • friend istream& operator>>(istream& s, point_t& rhs);
     • friend ostream& operator<<(ostream& s, const point_t& rhs);
   • The [ ] subscript operator.
   • A distance member function (double distance(point_t& rhs);) that computes and returns the Euclidean distance between this point and the rhs point: sqrt((x₁-x₂)² + (y₁-y₂)²)
   • The point_t class should store the x- and y-coordinates in a private std::vector<double> container.

Requirements

1. Your code should be such that the following main() routine works unaltered:

   int main(int argc, char *argv[])
   {
           point_t                         point;
           std::vector<point_t>            points;
           std::vector<point_t>::iterator  pit;
   
     // read input file consisting of names and id codes adding entities to list
     while(!std::cin.eof()) {
       std::cin >> point;
       if(std::cin.good()) 
         points.push_back(point);
     }
   
     // now play it back
     std::cout << "*** printing list" << std::endl;
   
     for(int i=0; i<points.size(); i++) {
       std::cout << points[i] << std::endl;
     }
   
     // try it again...
     std::cout << "*** printing list again" << std::endl;
   
     for(int i=0; i<points.size(); i++) {
       std::cout << point[i] << std::endl;
     }
   
     std::cout << "*** printing point coords" << std::endl;
   
     // get at x- and y-coords of p_i
     for(int i=0; i<points.size(); i++) {
       std::cout << "p_i[0] = " << points[i][0] << " ";
       std::cout << "p_i[1] = " << points[i][1] << std::endl;
     }
   
     std::cout << "*** checking distance function" << std::endl;
   
     // check distance between two points
     std::cout << "|p_0 - p_1| = " << points[0].distance(points[1]) << std::endl;
   
     // clear list via STL clear() function (memory leak if point_t used new!!)
     std::cout << "*** deleting list" << std::endl;
     points.clear();
   
     // nope ... see if we can delete an empty list
     std::cout << "*** deleting list again" << std::endl;
     points.clear();
   
     // prove we survived
     std::cout << "*** done" << std::endl;
   }
   	

Input

1. The pointdata.txt file used to test the above program is:

   15 14
   600 320
   104 29
   19 78
   450 321
   	

Output

1. Expected output with the above input file is:

   *** printing list
   15.00, 14.00
   600.00, 320.00
   104.00, 29.00
   19.00, 78.00
   450.00, 321.00
   *** printing list again
   15.00, 14.00
   600.00, 320.00
   104.00, 29.00
   19.00, 78.00
   450.00, 321.00
   *** printing point coords
   p_i[0] = 15.00 p_i[1] = 14.00
   p_i[0] = 600.00 p_i[1] = 320.00
   p_i[0] = 104.00 p_i[1] = 29.00
   p_i[0] = 19.00 p_i[1] = 78.00
   p_i[0] = 450.00 p_i[1] = 321.00
   *** checking distance function
   |p_0 - p_1| = 660.20
   *** deleting list
   *** deleting list again
   *** done
   	

Supplemental

1. Here is a Makefile that you can use to compile the project:

   .SUFFIXES: .c .o .cpp .cc .cxx .C
   
   UNAME = $(shell uname)
   PLATFORM = $(shell uname -p)
   
   CC = g++
   COPTS = -g -Wall
   
   INCDIR =
   LIBDIR =
   
   ifeq ("$(shell uname)", "Linux")
   LIBS = -lm
   else
   ifeq ("$(shell uname)", "Darwin")
   LIBS = -framework Foundation -lstdc++
   endif
   endif
   
   .c.o:
   	$(CC) -c $(INCDIR) $(COPTS) -o $@ $<
   
   .cpp.o:
   	$(CC) -c $(INCDIR) $(COPTS) -o $@ $<
   
   all : main
   
   OBJECTS = \
   point.o
   
   main : $(OBJECTS) main.o
   	$(CC) -o $@ $(INCDIR) $(COPTS) $(OBJECTS) $@.o $(LIBDIR) $(LIBS)
   
   point.o: point.h point.cpp
   
   clean :
   	rm -f *.o
   	rm -rf main main.app
   	

Turn in

1. A README file containing
   1. Course id--section no
   2. Name
   3. Brief solution description (e.g., program design, description of algorithm, etc., however appropriate).
   4. Lessons learned, identified interesting features of your program
   5. Any special usage instructions
2. Makefile
3. source code (.h headers and .cpp source)
4. object code (do a make clean before tar)

How to hand in

Grading scheme