1 / 50

Main Index

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

licia
Download Presentation

Main Index

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  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.

More Related