Main Index

1. Software Design Overview(2) • Software Design Stages(3 slides) • Program Design • -The Traditional Approach (3) • calendar Class(3 slides) • date Class(2 slides) • Implementing the Calendar Class • Error Handling • -Program Termination (2 slides) • -Setting a Flag (3 slides) Chapter 2 – Object Design Techniques 1 Main Index Contents • C++ Exceptions (3 slides) • Object Composition • timeCard Class(3 slides) • Implementing timeCard Class • -Constructor • -punchOut() • Operator Overloading • -With Free Functions (3 slides) • -With Friend Functions (2 slides) • -Stream I/O Operators • Operator Functions • time24 Class(5 slides) • Member Function Overloading • -Implementation • Summary Slides (15 slides)

2. Software Design Overview • A computer program begins with a problem that the client wants solved. • The process of building the program starts with an analysis of the problem. • It proceeds through a series of stages to produce a product that is reliable and easy to maintain.

3. Software Design Overview • Prior to the standardization of the software development life cycle: • Programmers added code to software with little attention to its integration into the system. • Over time systems deteriorated and became so difficult to update that programmers had to develop new software to replace them.

4. 4 Main Index Contents Software Design Stages • Request: • Client perceives a need for a software system to solve a problem. • A computer consultant undertakes a feasibility study for the project. • Analysis: • A systems analyst develops the requirements of the system and creates a functional specification that includes a list of needs and special requirements.

5. 5 Main Index Contents Software Design Stages • Design: • Translate the functional specification into an abstract model of the system. • Identify the components of the system and develop algorithms that will be used for implementation. • Implementation: • Use a programming language and the design specification to code the different components of the system.

6. 6 Main Index Contents Software Design Stages • Testing: • Check the program for logical and runtime errors and verify that the system meets the specifications of the client. • Maintenance: • Periodically update the software to stay current and to respond to changing needs of the client.

7. Program DesignThe Traditional Approach • Uses a top-down strategy. • System viewed as a layered set of subprograms. • Execution begins in the main program and information flows in the system through a series of function calls and return values. • For large problems this approach can fail: • Design changes in subprograms near the top of the hierarchy can require expensive, time-consuming changes in the subprograms at lower levels.

8. Program DesignObject Oriented Approach • More of a bottom-up approach • System viewed as interacting objects • Design focuses on identifying objects and their interactions through use of “scenarios” • Data (objects) are active rather than passive • UML (Unified Modeling Language) • Class diagrams • Use cases (user’s view of system) • Interaction Diagrams (sequences, collaborations, …)

9. Program Testing & Debugging • Unit testing • Integration testing • Verification – meets requirements • Validation – meets user’s needs • Syntax vs. Semantic (logical) errors • Black-box vs. White-box testing • Test data (inputs in range, out of range, boundary)

10. Program DesignMonthly Calendar Example • Request: Display month/year calendar • Analysis: Inputs? Form of display? • Design: calendar class • public member functions • Required data & support functions • Date class: supports calendar class • day of week for 1st day, • days in month, etc. • Testing based on known calendars

11. class calendar { public: calendar(int m = 1, int y = 1900); // initialize the month and year for // display. // precondition: month is in the // range 1 to 12 and year // is 1900 or later CLASS calendar Declaration “d_cal.h” 11 Main Index Contents

12. void displayCalendar() const; // display the calendar with a header // and a table of dates int getMonth() const; // return the current month for the // calendar int getYear() const; // return the current year for the // calendar CLASS calendar Declaration “d_cal.h” 12 Main Index Contents

13. void setMonth(int m); // update the month for the calendar // precondition: m must be in the // range 1 to 12 void setYear(int y); // update the year for the calendar // precondition: y must be >= 1900 private: date d; // 1st day of month, year int firstDay() const; // day of week }; CLASS calendar Declaration “d_cal.h” 13 Main Index Contents

14. CLASS date CLASS date “d_date.h” “d_date.h” Constructor Operations date(int mm = 1, int dd = 1, int yy = 1900); Initializes the date with default January 1, 1900 int daysInMonth(); Returns the number of days for the month. If the year is a leap year, month 1 (February) returns 29 int getMonth(); Returns the month for the current date date Class

15. CLASS date “d_date.h” Operations int getYear(); Returns the year for the current date bool isLeapYear(); Return true if the year is a leap year, otherwise returns false int numberOfDays(); Return the number of days into the year void setMonth(int mm); Update the month in the current date void setYear(int yy); Update the year in the current date date Class

16. 16 Main Index Contents Implementing the calendar Class setMonth() : // update the current month void calendar::setMonth(int mm) { // verify that mm is a valid month if (mm < 1 || mm > 12) throw dateError("calendar setMonth():",mm, "invalid month"); // set d to new month d.setMonth(mm); }

17. Error handling: Program Termination Terminating the program in case of error: time24 time24::duration(const time24& t) { // convert times to minutes int currTime = hour * 60 + minute; int tTime = t.hour * 60 + t.minute; // if t is earlier time, throw exception if (tTime < currTime) { cerr << "time24 duration(): argument " << " is an earlier time" << endl; exit(1); } else return time24(0, tTime-currTime); }

18. Error Handling:Setting a Flag Implementing duration() with an error flag: time24 time24::duration(const time24& t, bool& success) { int currTime = hour * 60 + minute; int tTime = t.hour * 60 + t.minute; time24 returnTime; // default time 0:00 success = true; // assume no error if (tTime < currTime) success = false; // error else returnTime = time24(0,tTime-currTime); return returnTime; // return 0:00 }

19. Error Handling:Setting a Flag The programmer can have the calling statement check the result of duration() by placing the call within a conditional expression. bool success; time24 currTime, nextTime, interval; ... interval = currTime.duration(nextTime, success); if (success == false) // check success and deal with an error { <take appropriate action> }

20. 20 Main Index Contents C++ Exceptions

21. 21 Main Index Contents C++ Exceptions Implementing duration() by throwing an exception: time24 time24::duration(const time24& t) { int currTime = hour * 60 + minute; int tTime = t.hour * 60 + t.minute; // throw error if t is earlier time if (tTime < currTime) throw rangeError("time24 duration(): \ argument is an earlier time"); else return time24(0, tTime-currTime); }

22. 22 Main Index Contents C++ Exceptions // call to function and handling of error try { time1.duration(time2); } catch (rangeError& re) { cerr << re.what(); // now do something to handle error here }

23. Object Composition • Object Composition: • refers to a condition that exists when a class contains one or more data members that are objects of class type. • Class included by composition == supplier class. • Class that includes an object by composition== client class.

24. class timeCard { public: timeCard(const string& ssno, double rate, int punchInHour, int punchInMinute); void punchOut(const time24& t); // assign t to punchOutTime and set // hasPunched to true, CLASS timeCard Declaration “d_tcard.h” 24 Main Index Contents

25. void writeSalaryInfo(); /* output a log that includes the beginning and ending times for the day's work, the amount of time worked, the pay rate and the earnings. precondition: throw a rangeError exception if worker has not punched out (hasPunched == false) */ CLASS timeCard Declaration “d_tcard.h” 25 Main Index Contents

26. private: string workerID; time24 punchInTime, punchOutTime; // supplier-class objects double payrate; bool hasPunched; }; CLASS timeCard Declaration “d_tcard.h” 26 Main Index Contents

27. Implementing the timeCard Class: Constructor Constructor: // use initialization list to initialize // data members. timeCard::timeCard( const string& ssno, double rate, int punchInHr, int punchInMin) : workerID(ssno), payrate(rate), hasPunched(false), punchInTime(punchInHr, punchInMin) {}

28. 28 Main Index Contents Operator Overloading For programmer-defined objects, functions are often needed to enable the comparisons. Example as a free named function: // compare two time24 objects bool equalTime(const time24& a, const time24& b) { // a and b are equal if they have the // same hour and minute values Return a.getHour()== b.getHour() && a.getMinute() == b.getMinute(); }

29. 29 Main Index Contents Operator Overloading- with Free Functions Operators (==, <, +=, …) may be overloaded as free functions or as class member functions. // compare two time24 objects bool operator== (const time24& a, const time24& b) { Return (a.getHour() == b.getHour()) && (a.getMinute() == b.getMinute()); }

30. 30 Main Index Contents Operator Overloading- With Friend Functions • Overloading an operator as a free function raises efficiency issues: • The function is independent of the class • Its implementation must use member functions to access the appropriate data members. • If a class does not provide the appropriate access functions, • The operator cannot be overloaded as a free function.

31. 31 Main Index Contents Operator Overloading- With Friend Functions • C++ allows a free function to be declared as a friend function in the class: • A friend function has access to the private members of the class. • Denoted in the class declaration by placing the keyword friend immediately before its prototype. • Despite having access to the private data members, a friend is not a member function of the class.

32. 32 Main Index Contents Operator Overloading- with Friend Functions Friend function example. // prototype friend bool operator== (const time24& a, const time24& b); // implementation (not a class member function) bool operator== (const time24& a, const time24& b) { Return (a.hour == b.hour) && (a.minute == b.minute); }

33. 33 Main Index Contents Operator Overloading- Stream I/O Operators A class can overload the stream operators << and >> as friend functions. operator function prototype for each operation: (Output) <<: friend ostream& operator<< (ostream& ostr, const className& obj); (Input) >>: istream& operator>> (istream& istr, className& obj);

34. Member Function Overloading // update time by adding a time24 object // or an int time24& operator+= (const time24& rhs); // lhs += rhs time24& operator+= (int min); // lhs += min

35. Member Function Overloading-Implementation- // implement += by using addition with // operands *this and rhs time24& time24::operator+= (const time24& rhs) { // add *this and rhs using overloaded + // operator *this = *this + rhs; // return a reference to the current // object return *this; }

36. Lecture 3 (start here) • Take a look at rational class example

37. 37 Main Index Contents Summary Slide 1 • §- The software life cycle consists of: • A Request phase • An Analysis phase • A Design phase • An Implementation phase • A Testing phase • The Maintenance phase • §- All share equal importance in the Software Development Lifecycle

38. 38 Main Index Contents Summary Slide 2 §- The request phase - Meet with the client to discuss the needs and requirements for a software system. - Perform a feasibility study to see if building a software system is cost effective.

39. 39 Main Index Contents Summary Slide 3 §- The analysis phase - Determine the system requirements. - Systems analyst determines requirements and is the intermediary between the client and the software engineers. - Result: a functional specification of the software system that includes a list of needs and special requirements.

40. 40 Main Index Contents Summary Slide 4 §- The design phase - Create abstract model of the problem. - Identify objects: building blocks of the program. §- Determine how objects collaborate and interact to solve the problem. - Create class declarations, including their attributes and public member functions. §- Describe how classes are related - Design the algorithms that allow the classes to effectively interact.

41. 41 Main Index Contents Summary Slide 5 §- The implementation phase - Convert the design into a program. - Implement the classes independently and verify the action of their member functions. - Implement program units that coordinate object interaction. - Code the main program that manages the overall execution of the software system. §- Often, the implementation stage will discover errors or oversights in design.

42. 42 Main Index Contents Summary Slide 6 §- The Testing Phase - Analysis, design, and implementation phases interact to bring about modifications and corrections to the specifications and the code. §- effective interaction among the phases depends on frequent and systematic testing. - Test the classes and functions which are the individual units of the software system - perform integrative testing to ensure that the units fit together to create a program that runs correctly and efficiently.

43. 43 Main Index Contents Summary Slide 7 §- Program maintenance phase - Begins as soon as the client installs the system. - The client will identify bugs or features that must be changed or added. - A client may add new hardware and/or find new applications for the software. §- Modern software systems must be regularly upgraded or they will eventually become obsolete and unusable.

44. 44 Main Index Contents Summary Slide 8 • §- Handling errors during function execution is an important aspect of program design. • - There are three fundamental ways to handle errors: • Output an error message and terminate the program. §- Generally avoided unless necessary. • Return a Boolean flag from the function call indicating that an error occurred. §-Grants the advantage of leaving the decision about how to handle the error to the calling code block. • use the C++ exception mechanism. §- The best approach.

45. 45 Main Index Contents Summary Slide 9 §- C++ exceptions are handled by three keywords: §- try - Function calls and code that may generate an exception are placed in a try block.

46. 46 Main Index Contents Summary Slide 9a §-catch - The exception handler. - Outputs an error message and either takes corrective action or terminates the program.

47. 47 Main Index Contents Summary Slide 9b §- throw - Bypasses the normal function return mechanism searches chain of previous function calls until it locates a catch block.

48. 48 Main Index Contents Summary Slide 10 §- Operator overloading: - important feature of object design in C++. - redefines an operator to accept operands of the class type. - Designing a class to take advantage of familiar operator notation makes the class easier to use and extends its flexibility.

49. 49 Main Index Contents Summary Slide 11 §- 1st way to overload an operator: - implement a free function using the operator function format. §- requires the use of class member functions that give the function access to the private data of an object. §- 2nd way to overload an operator - declare an operator function as a friend of a class.§- The function is not a class member but has access to the private section of the class. - This technique avoids calling class access functions.

50. 50 Main Index Contents Summary Slide 12 §- Some operators must be overloaded as class member functions. - Overload unary operators and binary operators that modify an object as member functions. §- An operator overloaded in this fashion has one less operand than the corresponding operator function. §- In the case of a binary operator, the left operand is the object itself, and the right operand is the argument. - A unary operator has no argument list.