1 / 61

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

Learn about the stages of software design, the traditional approach, and object design techniques for program implementation.

hodgesd
Download Presentation

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

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

More Related