Chapter 11. The first objective here is to make use of the list class definition from a previous lab. Recall the class definition for ShapeList.

Transcription

1 Chapter 11 A portion of this lab is to be done during the scheduled lab time. The take-home programming assignment is to be turned in before the next lab; see the lab website. The in-lab portion is worth 40% of the lab credit; the programming assignment is worth the other 60%. See the website for details on how the programming assignment will be graded. You are not responsible for user errors in input unless specified in the assignment. Feedback will be provided explaining your grade on each assignment. It is important that you complete each step before going on to the next, as the exercises build upon one another. You will find it helpful to diagram the action of each method or function as you go along. If you have difficulty in some step, DO NOT proceed before resolving it; seek assistance from your lab proctor. You will not be able to fully appreciate the remaining content of the lab and you are likely to compound the problem. Contents 1 Introduction 2 An Extensible List Class 3 Shapes 4 Polygon 5 Reading and Writing Shape Data 5.1 Hint: Reading a Polygon 6 Virtual Methods 7 Virtual Destructors Introduction This lab illustrates how virtual functions are used to evaluate function calls based on the type of the object involved. To do so, the example from the previous lab is continued. Topics Covered in this Lab: virtual functions polymorphism Questions Answered in this Lab: What is a virtual function? What is polymorphism? What is a pure virtual function? Demonstrable Skills Acquired in this Lab: ability to utilize virtual functions when appropriate understanding of the advantages of implementing polymorphism ability to utilize pure virtual functions when appropriate Create a project oop10 with the empty C++ header and source files listed below; upon completion of the in-lab portion of this assignment, submit all of these files in zip file oop10il.zip. Makefile main.cpp ShapeList.h & ShapeList.cpp Shape.h & Shape.cpp Circle.h & Circle.cpp Square.h & Square.cpp Polygon.h & Polygon.cpp project file function main() list of geometric shapes base class for all geometric shapes oop10in.txt sample data An Extensible List Class The first objective here is to make use of the list class definition from a previous lab. Recall the class definition for ShapeList. class ShapeList : private std::list <Shape*> ShapeList ; void void (void); add (Shape* newshape); write (ostream& outfile) const; ostream& operator<< (ostream& outfile, const ShapeList& shapes); You should copy the relevant class definition and implementations into your project folder for this lab. If you did not complete the ShapeList in a previous lab, take the time to define it now so that the add() method uses the std::list's push_back() method to add the shape to the list. Shapes Now, you will want to copy your definitions for the Shape and descent classes Circle and Square into this project. Their interfaces are shown below (you may or may not already have the write() methods - you will be adding them later).

2 class Shape Shape (double x, double y) : refx(x), refy(y) double refx; double refy; ; class Circle : public Shape Circle (double x, double y, double r) : Shape(x, y), radius(r) double radius; ; class Square : public Shape Square (double x, double y, double s) : Shape(x, y), side(s) double side; ; Polygon Now you will add a new kind of Shape to your library. Create a class Polygon that should be a derived class of Shape. A Polygon is a Shape that has an array of (three or more) vertices defining the shape. Each of the vertices will be a Cartesian these 2-dimensional vertices, add the following helper class: coordinate pair. To help with direct support for ****************************** In Point2D.h ******************************* #include "Shape.h" * Point2D is a 2-dimensional Cartesian * point with Real-valued coordinates. class Point2D // attributes: double x; ///< x-coordinate of this point double y; ///< y-coordinate of this point // constructors: * construct a Point2D given the x- and y- * coordinates of its location. Point2D(double x, double y) : x(x), y(y) * default-construct a Point2D at the origin. Point2D() : x(0), y(0) ; std::ostream& operator<<(std::ostream& strm, const Point2D& point); ***************************** In Point2D.cpp ****************************** #include "Point2D.h" * Overloaded stream insertion operator to allow a Point2D to * be displayed in a standard ostream. strm the stream to write the Point2D into point the Point2D object to output the modified `strm` is returned std::ostream& operator<<(std::ostream& strm, const Point2D& point) return strm << "(" << point.x << ", " << point.y << ")"; Your Polygon's constructor should take an array of Point2D objects, along with the size of that array, and should dynamically allocate a corresponding array internally and copy those points into it. The first point in the array should be used for the reference - and -coordinate for the Polygon. The Polygon's destructor will then be responsible for freeing the memory associated with the array of vertices. A reference prototype for a Polygon is shown below: class Polygon : public Shape Polygon (const Point2D* vertices, int vertex_count); ~Polygon(); Point2D* vertices; int vertex_count;

3 ; Write the code to implement your Polygon class now. Reading and Writing Shape Data Add write() methods with identical prototypes to each of the Shape object descendants. Also, add a write() method to the Shape implementation in order to provide default behavior; for example, the reference location can be written. This method will be called should a new be defined without including its own write() method. The write() methods of each descendant Shape should also invoke Shape::write() to display their respective reference locations. In order to test the execution of the various write() methods, create a data file oop10in.txt with the following contents. Circle Square Circle Polygon Square Circle Polygon Diagram the objects indicated by the file. FOR IN-LAB CREDIT: Explain the diagram to the lab instructor. Use the following as the body of function main() to test all methods to this point. ifstream infile ("oop10in.txt"); if (! infile) cout << "Input file could not be opened! Exiting!\n"; exit (1); ShapeList shapes2; while (! infile.eof ()) string objecttype; infile >> objecttype; if(objecttype == "Square") //add a Square object to the list from the file else if (objecttype == "Circle") //add a Circle object to the list from the file else if (objecttype == "Polygon") //add a Polygon object to the list from the file else cout << "Unexpected object type: " << objecttype << endl; exit(2); // end while not eof cout << "Object locations:\n" << shapes2 << endl; Hint: Reading a Polygon The Polygon specification in the data file looks like the following: Polygon x0 y0 x1 y1 x2 y2 x3 y3 [...] xn yn You have no way of knowing how many pairs of - and -coordinate pairs to expect for any individual Polygon (although perhaps for this exercise an upper limit of 100 would be reasonable). You do know that the numbers will always come in pairs, and that the next item in the file following the last -coordinate (yn above) will be the name of the next Shape (or the end-of-file if the Polygon is the last line in the file). These facts lend themselves well to either of two general approaches, described below: Approach 1: Raw Stream Extraction You can take advantage of the fact that the stream extraction operation will fail without removing any tokens from the stream when it encounters data that doesn't match the expected type. So when the stream extraction operator expects to read the next -coordinate but encounters a string (or the end-of-file), it will fail without removing anything more from the stream. With this in mind, your algorithm for reading the vertices of the polygon from the file might look like: - create an array of points large enough to store any possible Polygon (or be prepared to re-size an array dynamically) - set up storage for a counter to count the number of vertices read, as well as the x- and y-coordinates of the next vertex - in a loop, attempt to extract the next x- and y-coordinate pair * as long as this extraction _succeeds_ (doesn't return a `false`-equivalent value): - set the next vertex in the array to the coordinates read - increment the count of the total number of vertices * once the attempt to read the coordinate pair fails:

4 - create the new Polygon and place it into the shape list (you now have all of the vertices and the count). - if the stream _did not_ fail because of encountering the end-of-file: - reset the stream's state by `clear()`-ing it so that the next read (which will be a Shape name) can succeed. Approach 2: One Line at a Time with Help from istringstream It would be very easy to read the entire line (containing the shape name and all of its coordinate pairs) into a using getline(). Then you have a simpler problem to solve: How do you extract all of the values from this string? The C++ standard library provides an elegant solution for this: std::istringstream A std::istringstream object (defined in the <sstream> library) is able to behave like an input stream, but can be initialized from a. Consider the following simple example (that is not part of the solution you are trying to write, but is very related): example"picard 4 7 alpha tango"; std::istringstream issexample; who; int num1, num2; word1, word2; iss >> who >> num1 >> num2 >> word1 >> word2; if(num1 == 4 && num2 == 7 && word1 == "alpha" && word2 == "tango") who[0] = toupper(who[0]); std::cout << who << " has activated self destruct!\n"; This example will print "Picard has activated self destruct!". For more information about std::istringstream (and its opposite, std::ostringstream), see Execute the program and note that the output only shows the information provided by the Shape::write() method, not the individual methods defined in the derived classes. FOR IN-LAB CREDIT: Modify the data to test the program thoroughly and demonstrate it for the lab instructor, explaining why only the data from the Shape class is being shown. Virtual Methods Even with a Shape* pointer, a problem remains: method ShapeList::write() invokes Shape::write() for each object, but Circle::write(), Square::write(), etc. have access to more specific data concerning each object. Method Shape::write() can only display the reference location of the object, since the linker uses static binding for these methods. Virtual methods address this problem; change the prototype for Shape::write() to the following: virtual void write (ostream& outfile) const; A call to this method via a Shape* pointer will be automatically referred to the write() method of the descendant class, should there be one (e.g., Circle or Square); otherwise, Shape's write() method is executed. This is the essence of polymorphism. The decision on which write() method to invoke is delayed until run-time, or dynamic binding, and is based on the inheritance relationships of the involved classes at that time. Add the virtual keyword to all of the write() method prototypes/headers, re-test your program to verify that the appropriate write() methods for each Shape are being used. Note: Adding the virtual keyword in the derived classes was not strictly necessary, but is considered a best practice. FOR IN-LAB CREDIT: Demonstrate the correct output from all of the write() methods to your lab instructor. Virtual Destructors Inheritance introduces a destructor-based problem which must be addressed; some background must be covered to explain and then resolve it. When inheritance is involved, destructors are called in the reverse order that the corresponding constructors were called. This follows from the observation that any descendant method knows about its ancestors' methods; it can access them even during destruction, so the ancestral portion of the object must not be destroyed before that of a descendant. Add a destructor with the following one-line implementation to class Shape: cout << "Shape::~Shape\n"; Using this format, add destructors to the following classes: Circle, Square, Polygon and ShapeList. Execute the program again and note that the messages are written for ShapeList and Shape only, in that order. The first message, that for ShapeList, occurs because the automatic variable of type ShapeList goes out of scope as function main() ends. The Shape destructors are called because the std::list destructor deletes each of the items in the list. The destructors for the descendants of Shape are not being called, because the ShapeList is only aware of the concept of a Shape, and the list items are being maintained as pointers to Shapes. The solution to this problem is to make ancestral destructors virtual. Modify the Shape destructor prototype as follows. virtual ~Shape (void); Execute the program again to see that the descendant shapes are now being destroyed. This includes the Polygon, which was actually managing dynamic resouces that would have been leaked if it were not destroyed properly.

5 FOR IN-LAB CREDIT: Verify for the lab instructor that the written order of destructor calls is descendant-to-ancestor. Zip up these files: Makefile main.h Shape.h Shape.cpp Circle.h Circle.cpp Square.h Square.cpp Polygon.h Polygon.cpp ShapeList.h ShapeList.cpp oop10in.txt FOR IN-LAB CREDIT: Name the file oop10il.zip and upload to CSCADE.