Software Design Overview: Stages, Program Design, and Implementation Techniques

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 of the software to stay current and to respond to changing needs of the client.

7. Program DesignThe Traditional Approach • The design phase of the software development life cycle translates the functional specifications from the analysis phase into an abstract model. • The traditional design approach uses a top-down strategy. • The model views a system 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.

8. Program DesignThe Traditional Approach • When the problem becomes too large this approach can fail: • The complexity overwhelms the ability of a single person to manage the hierarchy of subprograms. • Design changes in subprograms near the top of the hierarchy can require expensive, time-consuming changes in the subprograms at lower levels in the chart.

9. 9 Main Index Contents Program DesignThe Traditional Approach

10. 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” 10 Main Index Contents

11. 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” 11 Main Index Contents

12. 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: . . . ; CLASS calendar Declaration “d_cal.h” 12 Main Index Contents

13. 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

14. 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

15. 15 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); }

16. Handling Errors • 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.

17. 17 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.

18. Error handling: Program Termination Implementing duration() by terminating the program in case of error: time24 time24::duration(const time24& t) { // convert current time and time t to // minutes int currTime = hour * 60 + minute; int tTime = t.hour * 60 + t.minute; // if t is earlier than the current time, // throw an exception

19. Error handling: Program Termination if (tTime < currTime) { cerr << "time24 duration(): argument is an earlier time" << endl; exit(1); } else return time24(0, tTime-currTime); }

20. Error Handling:Setting a Flag Implementing duration() with an error flag: time24 time24::duration(const time24& t, bool& success) { // convert current time and time t to // minutes int currTime = hour * 60 + minute; int tTime = t.hour * 60 + t.minute; // time returned. default value of 0:00 // is the return // time if an error occurs time24 returnTime;

21. Error Handling:Setting a Flag // assume that no error will occur success = true; // if t is earlier than the current time, // assign false to success if (tTime < currTime) success = false; else // successful. assign duration to // returnTime returnTime = time24(0, tTime-currTime); return returnTime; }

22. 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> }

23. 23 Main Index Contents C++ Exceptions

24. 24 Main Index Contents C++ Exceptions Implementing duration() by throwing an exception: time24 time24::duration(const time24& t) { // convert current time and time t to // minutes int currTime = hour * 60 + minute; int tTime = t.hour * 60 + t.minute; // if t is earlier than the current time, // throw an exception if (tTime < currTime) throw rangeError( "time24 duration(): argument is an earlier time"); //rangeError is available in d_except.h of //your SW supplement else return time24(0, tTime-currTime); }

25. 25 Main Index Contents C++ Exceptions Catch the error – in the driver time24 currenTime, nextTime, interval; cout << “Enter the current time and a later time: “; cin >> currentTime >> nextTime; try { interval = currentTime.duration(nextTIme); cout << “The interval is “ << interval << endl; } catch (const rangeError& re) { // output the message in re and exit the program cerr << re.what() << endl; exit(1); } continue …

26. 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.

27. 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” 27 Main Index Contents

28. 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” 28 Main Index Contents

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

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

31. Implementing the timeCard Class: punchOut() punchOut(): void timeCard::punchOut(const time24& t) { punchOutTime = t; hasPunched = true; }

32. 32 Main Index Contents Operator Overloading For programmer-defined objects, functions are needed to enable the comparisons. Example: // 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(); }

33. 33 Main Index Contents Operator Overloading- with Free Functions • Operators may be overloaded as • free functions or as • class member functions. • The concepts have important differences; their syntax is dealt with separately.

34. 34 Main Index Contents Operator Overloading- with Free Functions • A free function could be used to compare two class objects. // compare two class objects bool equalItem(const className& a, const className& b) { return a.getObject1()== b.getObject1() && a.getObject2() == b.getObject2(); }

35. 35 Main Index Contents Operator Overloading- with Free Functions • The same comparison can be made using operator overloading. bool operator== (const className& lhs,const className& rhs); If the operator function is a free function, its implementation must use the public-member function in the time24 to access the data.

36. 36 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.

37. 37 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.

38. 38 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);

39. Operator Functions • Assume the string s = "Hello" and t = " World!". • The string expression s + t returns a string that is the concatenation of s and t. • The op. function for the op. + with arguments lhs and rhs and return type string is string operator+ (const string& lhs, const string& rhs);

40. class time24 { public: // constructor with starting time time24(int h = 0, int m = 0); // binary + operators: add minute // and time24 objects friend time24 operator+ (const time24& lhs, const time24& rhs); friend time24 operator+ (const time24& lhs, int min); friend time24 operator+ (int min, const time24& rhs); CLASS time24 Declaration “d_time24.h” 40 Main Index Contents

41. // binary - operator: subtracts two time24 // objects if rhs is not earlier than lhs. // if this precondition is not satisfied, // throw rangeError exception friend time24 operator- (const time24& lhs, const time24& rhs); // comparison operators friend bool operator== (const time24& lhs, const time24& rhs); friend bool operator< (const time24& lhs, const time24& rhs); . . . CLASS time24 Declaration “d_time24.h” 41 Main Index Contents

42. . . . private: int hour, minute; // data members void normalizeTime(); // put time units in range }; CLASS time24 Declaration “d_time24.h” 42 Main Index Contents

43. class time24 { public: . . . // input a time for object t friend istream& operator>> (istream& istr, time24& t); // output the time in t as // hour:minute friend ostream& operator<< (ostream& ostr, const time24& t); CLASS time24 Declaration - I/O operators “d_time24.h” 43 Main Index Contents

44. private: int hour, minute; // data members void normalizeTime(); // put time units in range }; CLASS time24 Declaration - I/O operators “d_time24.h” 44 Main Index Contents

45. 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

46. 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; }

47. 47 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

48. 48 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.

49. 49 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.

50. 50 Main Index Contents Summary Slide 4 §- The design phase (continued) - Translate data from the analysis phase into an abstract model of the problem. - Identify the objects which are the building blocks of the program. §-Determine how these objects should collaborate and interact to solve the problem.