Shapes leading to CAD system project

Transcription

1 EXERCISES Shapes leading to CAD system project Strings leading to distribution control project Tables leading to infinite precision arithmetic project Conversions leading to instrument control project Averages leading to employee information management project

2 Part 8, Page 2 C++ Programming

3 Shapes leading to CAD system project Project scope and objectives: Develop a set of shape classes with methods for computing perimeter, area, and volume. By adding coordinates, this can be extended to handle collections of intersecting shapes. 1. Define structures for the following: a. Triangle - consisting of the three lengths of sides a, b, and c. b. Rectangle - consisting of the two lengths of orthogonal edges. c. Parallelogram - consisting of the two lengths of meeting edges and the included interior angle. d. Circle - consisting of the length of the radius. 2. For each structure, write functions that initialize the object, compute the perimeter of the object, and compute the area of the object. 3. Convert the structures into data types, then merge the programs to compute perimeter and area for each of these objects by overloading functions perimeter and area. 4. Convert the structures for the four objects into classes, then write constructor functions for each object. 5. Write an output function that prints out the relevant data for each type of object including the object type, the relevant dimensions, perimeter, and area. 6. Overload the + operator to add the perimeters of any 2 objects. Overload the * operator to add the areas of any two objects. 7. Re-write the code to place the declarations into a separate.h file and then include that file into all of the program files. Compile the programs to verify that they still work correctly. 8. Convert the short functions in your code to inline functions. Exercises Part 8, Page 3

4 9. Restructure the classes so that all of the objects are derived classes from a base class shape. Also, make parallelogram a derived class of rectangle that inherits the basic properties of rectangle, adding the included interior angle as an additional attribute. Create virtual functions area and perimeter in the shape base class. 10. Make the overloading of the + and * operators virtual. Overload the << operator to print out the name of the object type (triangle, rectangle, etc.). 11. Re-write the output functions to include manipulators that make the output more presentable. 12. Re-write the constructor functions to check to make sure that the values given to the constructor result in a legal shape. For example, the sum of the two shortest sides in a triangle must not be less than the length of the longest side; lengths must not be negative; the included angle in a parallelogram must be less than 180 degrees. 13. Re-write the error checking code to throw an exception for illegal shape. Write appropriate code to catch the exceptions. 14. Add a description to each rectangle and circle, using multiple inheritance from the shape and the string base classes (use the string class from string5.h). 15. Add additional shape, including solids. Structure the base class shape into two subclasses, one for planar objects and the other for solids. Write a volume function that applies only to solids. Write/re-write the functions for perimeter, area, volume and overload the operators +, *, and << using templates. 16. (Extension to CAD) Add sufficient x, y, z coordinates (and angles, if desired) to each object to fix it in three dimensional space. (This is conceptually difficult in the general case if you want to make sure you determine a single location without overdetermining the object so as to force additional error checking.) Write a function that takes two objects as parameters and determines the area of overlap. (Again, this is a conceptually difficult function to write that may involve numerical integration.) Part 8, Page 4 C++ Programming

5 Strings leading to distribution control project Project scope and objectives: Develop a string class that includes string length with methods for the usual C string functions and a + operator for string concatenation. Use these strings to access files and compute file length. By adding files containing file lists, this can be extended to control the distribution of files for a software project to many targets. 1. Define a structure for a string containing both a string length and a fixed length area of 100 characters for the contents of the string. 2. Write functions that initialize strings, return the length of the string, copy strings, and print the contents of the string. 3. Convert the structure into a data type. Overload the string functions strlen and strcpy to behave the same way as the built-in C functions. 4. Convert the structure into a class, then write constructor functions for each object. Change the area for the contents of the string to a variable length area that dynamically allocates space using the new operator. Write destructor functions to recover the dynamically allocated space. Write a copy constructor. Temporarily insert additional code into the constructor and destructor functions to trace exactly which strings are created and destroyed when. 5. Write an output function that prints out the relevant data for each string, including the fact that it is a string, the length of the string, and the contents of the string. Overload the << operator so that the contents of the string are inserted into the output stream. 6. Overload the + operator to concatenate two strings. Overload the - operator to search for and remove the first occurrence of the second string within the first string. (If the second string is not found in the first string, then the first string remains unaltered.) Remember, the results of these operations are strings. Exercises Part 8, Page 5

6 7. Re-write the code to place the declarations into a separate.h file and then include that file into all of the program files. Compile the programs to verify that they still work correctly. 8. Convert the short functions in your code to inline functions. 9. Create a class structure so that all of the objects are derived classes from a base class text. Make string a derived class from text. Make textfile a derived class from text. Make filename a derived class from string. Printing a textfile means printing the entire contents of the file. Adding two textfiles means appending the contents of the second file to the first file. Asking for the length of a textfile means counting the number of characters in the file. (The length of the file is NOT kept within the class members - just the file name.). Create virtual functions strcat and strlen in the text base class. 10. Make the overloading of the + and - operators virtual. Overload the << operator to print out the name of the object type (string, filename, etc.) as well as the contents if a string or filename. 11. Re-write the output functions to include manipulators that make the output more presentable. Write a function that compares two files, finding either the line number and character position of the first difference between the two files, or verifying that the two files are character-for-character identical. Print the line number and character position of the first difference between the two files. Then overload the == operator for the textfile class to return TRUE if the two files are identical, FALSE if they are not. 12. Re-write the constructor functions to check to make sure that the constructor succeeds. For a string and filename, this means that the new function was able to allocate space. For a textfile and filename, this means that the path to the file (but not necessarily the file) exists and that the filename is in a legal format. 13. Re-write the error checking code to throw an exception for illegal text. Write appropriate code to catch the exceptions. 14. Add a class for a textfile containing filenames of text files, using multiple inheritance from the textfile and filenames base classes. Part 8, Page 6 C++ Programming

7 15. Write additional functions that implement some of the string functions in the C library for each of the classes using templates. Try writing additional functions that implement some of the character "functions." Because these functions work as macros for standard data types, be aware of potential problems. 16. (Extension to a software distribution system) Overload the strcpy function and << operator to copy a standard C string, the string that is a subclass of text, a filename, the contents of a textfile, or the contents of all the files in a textfile of file names. Allow destinations to allow directory names so that a list of files is copied to another directory with the same file names as the source files. Exercises Part 8, Page 7

8 Tables leading to infinite precision arithmetic project Project scope and objectives: Develop a set of classes capable of arbitrarily high precision computation with methods for computing simple tables. This project can extend to interaction will all existing numeric classes. 1. Write a C++ program that will print a table of numbers, their squares, and their cubes. The table should have a heading. Next, write two functions, one for squaring numbers and the second for cubing numbers. Call these functions to create the table instead of doing the computations within main. Finally, place the function for computing the square and the cube in a file different from the file containing main. 2. Write functions to process a whole number stored as an array of integers in which each integer array element contains one digit of the whole number. Write functions that initialize these arrays, return the value of the number (for small numbers), add 1 to the number, and add two numbers. When adding, form the sum for the least significant digit. If the sum is greater than 9, subtract 10 from the digit and add 1 to the next most significant digit. Limit whole numbers to values with less than 100 digits. 3. Convert the array of integers into an infinite precision whole number data type. Overload the + and - operators to behave like ordinary arithmetic with both integers and infinite precision whole numbers. 4. Convert the data type into a class, then write constructor functions for each value. Change the area for the contents of the value to a variable length area that dynamically allocates space using the new operator. Write destructor functions to recover the dynamically allocated space. Write a copy constructor. Temporarily insert additional code into the constructor and destructor functions to trace exactly which arrays of integers are created and destroyed when. Part 8, Page 8 C++ Programming

9 5. Write an output function that prints out the fact that it is dealing with an infinite precision value, the number of digits in the value, and the value itself, placing spaces every 5 digits from the right. Overload the << operator so that the value is inserted into the output stream, placing commas every three digits from the right (remember, output is printed left to right). 6. Overload the * operator to compute the product of two values, any mixture of integer and infinite precision. The product of two infinite precision numbers requires a temporary infinite precision value, but otherwise the code looks just like teaching a fifth grader long multiplication. Clean up the overloading of the + and - operators. Remember, the results of these operations are infinite precision numbers. Re-write the code as necessary to get tables of squares and cubes to work properly using infinite precision. 7. Re-write the code to place the declarations into a separate.h file and then include that file into all of the program files. Compile the programs to verify that they still work correctly. 8. Convert the short functions in your code to inline functions. 9. Create a class table that contains a string containing the name of the function; an infinite precision starting value; and an infinite precision ending value. Make table of squares and table of cubes derived classes from the base class table. Create virtual a function print_table to print the contents of the table in the table base class. 10. Overload the operator + for the table class. Adding two tables means running the table from the smaller starting value to the larger ending value. (Overloading the operator < for the infinite precision class may help.) The two tables must evaluate the same function. Make the overloading of the + operator virtual. Overload the << operator to print out the name of the function (square, cube, etc.). 11. Re-write the output functions for the table class to include manipulators that make the output more presentable. In particular, experiment with various formatting options within the infinite precision class, including the printing of preceding zeroes, to make tables line up. Exercises Part 8, Page 9

10 12. Re-write the constructor functions to check to make sure that the values given to the constructors are legal. For the table class, the beginning value for the table should be less than or equal to the ending value for the table. For the infinite precision class, the new operator must succeed in allocating space. 13. Re-write the error checking code to throw an exception for illegal tables or memory allocation errors for infinite precision arithmetic. Write appropriate code to catch the exceptions. 14. Add a description to square and cube functions, using multiple inheritance from the table and the string base classes (use the string class from string5.h). 15. Add additional tables using hard coded functions and pointers to functions. Structure the table class shape into two subclasses, one for single parameter functions (like square and cube) and the other for multiple-parameter functions (like min, max, and mod). Write/re-write the functions to overload the operators +, *, and << for both infinite precision and tables using templates. Using templates, write functions to provide full interaction between regular numeric types and the infinite precision numeric type. 16. (Extensions) Add sufficient coefficients to build a polynomial table class. Complete the implementation of the infinite precision class by overloading the standard C mathematical functions that take integer arguments and return integer results (pow and mod, for example, but not sin, cos, or sqrt Part 8, Page 10 C++ Programming

11 Conversions leading to instrument control project Project scope and objectives: Develop a set of measurement classes with methods for converting between various units of measurement. By adding error checking and input/output routines, this can be extended to handle instrument control. 1. Write a set of C++ functions that will convert temperatures from Celsius to Fahrenheit and Fahrenheit to Celsius; distance from meters to feet and feet to meters; time from seconds to hours and hours to seconds. Call these functions with test values from main. Finally, place the functions for converting temperatures a file different from the file containing main. 2. Create a structure for velocity in meters per second that contains a distance in meters and a time in seconds. For this structure, write functions that initialize the values, compute the velocity in meters per second, and compute the time it takes to travel one meter. Create a similar structure for velocity in feet per hour. 3. Convert the velocity structures into a data types. Also create data types for Celsius temperature, Fahrenheit temperature, distance in meters, distance in feet, time in seconds, and time in hours. Then merge the programs to compute velocity and time to travel a unit distance by overloading identically named functions. 4. Convert the velocity structures and temperature, time, and speed data types into classes, then write constructor functions for each object. 5. Write an output function that prints out the relevant data for each type of object including the object type, the relevant units of measurement, the value of the unit of measurement, and, for the velocity classes, the velocity and time to travel a unit distance. Exercises Part 8, Page 11

12 6. Overload the + operator to add the temperatures, times, distances, or velocities of objects, converting if necessary. The result should be in the units of measurement of the object on the left of the operator. Overload the / operator to accept a distance on the left, a time on the right, and generate a velocity as a result. The units of measurement for the result should be consistent with the left operand. 7. Re-write the code to place the declarations into a separate.h file and then include that file into all of the program files. Compile the programs to verify that they still work correctly. 8. Convert the short functions in your code to inline functions. 9. Restructure the classes so that all of the objects are derived classes from a base class measurement. Also, create new classes for acceleration (this class contains an additional time measurement over which the velocity developed - divide the velocity by this time to get acceleration) as a derived class of velocity. Further overload the / operator to take velocity on the left and time on the right to generate acceleration as the result. Create virtual functions for the overloading of the + and / operators in the measurement base class. 10. Make the overloading of the + and / operators virtual. Overload the << operator to print out the name of the object type (temperature, velocity, etc.). 11. Re-write the output functions to include manipulators that make the output more presentable. 12. Re-write the constructor functions to check to make sure that the values given to the constructor result in a legal values. For example, temperatures should not be below absolute 0, distances and times must not be negative. 13. Re-write the error checking code to throw an exception for illegal values. Write appropriate code to catch the exceptions. 14. Restructure the class inheritance to more closely model the situation by using multiple inheritance. Let measurement be the base class; the time, distance, and temperature classes be derived from measurement; velocity use multiple inheritance from time and distance; and acceleration use multiple inheritance from the time and the velocity derived classes. Part 8, Page 12 C++ Programming

13 15. Merge the time, distance, and temperature classes into a single class for each by adding a flag to indicate whether the measurement is in the British or metric system. Add additional derived classes as makes sense, for example, a temperature rate of change class derived from time and temperature. Write/re-write the functions for overloading the operators =, +, /, and << using templates. 16. (Extension to instrumentation) Add code for keeping track of arrays of measurements taken as a time series. Write the statistical functions necessary for averaging, smoothing, and discarding outliers. Exercises Part 8, Page 13

14 Averages leading to employee information management project Project scope and objectives: Develop a set of employee record classes with methods for computing the count, average, and total amounts in numeric fields. 1. a. Write a main function to compute the average of an array of ten numbers. Fill the array with initial values using assignment statements or using the extraction operator. b. Now write a function for computing the average of an array of n numbers, passing it a pointer to the array (the array name) and an integer, n, the number of valid elements in the array. Return the average as a double precision value. Do all input/output from main. c. Place the function for computing the average in a separate file from the file containing main. 2. Design a program to handle a structure named employee, adapting it to the structure (extracted from COBOL and C programs) on the following pages. Write functions that initialize various parts of the record and count the number of projects the employee is working on (a project code of 0 indicates the absence of a project). Use the average function to calculate the average project code. (Small project codes are assigned to easy projects, and large project codes are assigned to difficult projects, so the average project code measures the difficulty level the employee works at.) Create a second structure for contract employees. They will have the same structure, except that the employee number will be replaced by service time, and the maximum number of project codes is two. Write a second set of functions for contract employees. 3. Convert the telephone number substructure into a data type, then create an employee data type and a contract data type using the telephone data type as a component. Merge the programs to initialize parts of the record, count the number of projects, and compute the average project code by overloading functions. Part 8, Page 14 C++ Programming

15 COBOL and C STRUCTURES COBOL: 01 EMPLOYEE. 02 JOB-TITLE PICTURE X(7). 02 EMP-NO PICTURE X(9). 02 PAY-RATE PICTURE 9(2)V9(2). 02 NAME. 03 L-NAME PICTURE X(12). 03 F-NAME PICTURE X(8). 03 INIT PICTURE X. 02 OFFICE-ADDR. 03 BLDG PICTURE X(3). 03 ROOM PICTURE 9(3). 02 PROJECT-CODES OCCURS 5 TIMES PICTURE 9(2). 02 TELEPHONE-NO OCCURS 2 TIMES. 03 AREA-CODE PICTURE 9(3). 03 LOCAL PICTURE 9(7). C: struct { char char float pay_rate, struct { char } name, struct { char char job_title[8], emp_no[10], l_name[13]; f_name[9]; init; char bldg[4], int room; } office_addr, int project_codes[5], struct { int long int local; } telephone_no[2]; } employee; area_code, Exercises Part 8, Page 15

16 STRUCTURE EXAMPLE We wish to create a structure for the data processing record shown below: Job Title Analys t Emp No Pay Rate Name Last First M I Mud Joe N CSC Office Project Codes Addr Bldg Room Ar ea Telephone No Local Ar Local ea Note that the record has alphabetic, integer, and real data types (job title, employee number, pay rate). It has embedded structures (name, office address). It has an array of integers (project codes), and it has an array of embedded structures (telephone numbers). The code on the facing page shows how this would be coded in COBOL and shows the closest parallel structure in C. The C code is the most straightforward, but not the most elegant. More elegant code would involve using typedef rather than directly embedding the structures. C code is much more flexible, in that there are a great many ways in which this record can be coded. Part 8, Page 16 C++ Programming

17 4. Convert the structures for the two types of employees into classes, then write constructor functions for each record type. Define a constructor to dynamically allocate space for the employee information. Define a destructor to recover the allocated space. 5. Write an output function that prints out a data sheet for the employee or contractor, including the type of employee, all information in the employee record, the number of projects, and the average project code. 6. Overload the = sign to move data from one employee record to another. Further overload the = sign so that employee a = double b alters the pay rate. Overload the + operator so that employee a + int b assigns an additional project code to the employee. Overload the - operator so that employee a - int b removes a project code from the employee. (The integer will contain the project code number to be added/removed.) 7. Re-write the code to place the declarations into a separate.h file and then include that file into all of the program files. Compile the programs to verify that they still work correctly. 8. Convert the short functions in your code to inline functions. 9. Restructure the classes so that employee and contractor records are derived classes from a base class worker. Also, make supervisor a derived class of employee that inherits the basic properties of employee, adding the name of the department supervised as an additional attribute, and adding a set of 20 departmental project codes (that are counted as part of the project code total). The overloaded + operator adds to the supervisor s personal project codes. Overload the * operator to add to the supervisor s departmental project codes. The * operator can also operate on two workers, transferring all the personal project codes of the worker on the right to the departmental project codes of the supervisor on the left. Create virtual functions for calculating the number of projects working on and the average project code. 10. Make the overloading of the =, +, - and * operators virtual. Overload the << operator to print out the name of the worker type (employee, contractor, supervisor). Exercises Part 8, Page 17

18 11. Re-write the output functions to include manipulators that make the output more presentable. 12. Re-write the constructor functions to check to make sure that the values given to the constructor are legal. For example, none of the numbers can be negative. Also, re-write the overloaded +, -, and * operators to check for errors. For example, the + operator cannot be invoked legally with a sixth different project code for employees. The * operator is illegal if the total number of different departmental project codes would exceed 20 after the operation. 13. Re-write the error checking code to throw an exception for illegal constructors and operator usage. Write appropriate code to catch the exceptions. 14. Create a class for telephone number with all the necessary supporting functions. Replace the reference to the telephone number data types within worker by the use of multiple inheritance from worker and telephone number in the employee and temporary classes. This is done so that a class of worker without a phone number can be created. 15. Add an additional class for inactive workers. These workers will have no project codes or telephone numbers. Write/re-write the functions for project count, project average and overload the operators +, -, *, and << using templates. 16. (Extensions) Provide a mechanism for keeping track of groups of employees by department. (A department class that contains a dynamically allocated collection of employee records.) Provide an operator for processing all of the project codes of all members of the department to generate the supervisor s list of project codes on the fly without storing those codes in the supervisor s record. Part 8, Page 18 C++ Programming

19 Exercises Part 8, Page 19