slide1 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Main Index PowerPoint Presentation
Download Presentation
Main Index

Loading in 2 Seconds...

play fullscreen
1 / 59

Main Index - PowerPoint PPT Presentation


  • 164 Views
  • Uploaded on

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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Main Index' - adin


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.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide1

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)
software design overview
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.
software design overview1
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.
software design stages

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.
software design stages1

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.
software design stages2

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.
program design the traditional approach
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.
program design the traditional approach1
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.
slide10

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

slide11

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

slide12

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

date class

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
date class1

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
implementing the calendar class

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

error handling program termination
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

error handling program termination1
Error handling: Program Termination

if (tTime < currTime) {

cerr << "time24 duration(): argument is an earlier time" << endl;

exit(1); }

else

return time24(0, tTime-currTime); }

error handling setting a flag
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;

error handling setting a flag1
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; }

error handling setting a flag2
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> }

c exceptions

21

Main Index

Contents

C++ Exceptions
c exceptions1

22

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;

c exceptions2

23

Main Index

Contents

C++ Exceptions

// if t is earlier than the current time, // throw an exception

if (tTime < currTime)

throw rangeError(

"time24 duration(): argument is an earlier time");

else return time24(0, tTime-currTime); }

object composition
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.
slide25

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”

25

Main Index

Contents

slide26

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”

26

Main Index

Contents

slide27

private:

string workerID;

time24 punchInTime, punchOutTime; // supplier-class objects

double payrate;

bool hasPunched;

};

CLASS timeCard

Declaration

“d_tcard.h”

27

Main Index

Contents

implementing the timecard class constructor
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)

{)

implementing the timecard class punchout
Implementing the timeCard Class: punchOut()

punchOut():

void timeCard::punchOut(const time24& t)

{

punchOutTime = t;

hasPunched = true;

}

operator overloading

30

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();

}

operator overloading with free functions

31

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.
operator overloading with free functions1

32

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();

}

operator overloading with free functions2

33

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

operator overloading with friend functions

34

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.
operator overloading with friend functions1

35

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.
operator overloading stream i o operators

36

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

operator functions
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);

slide38

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”

38

Main Index

Contents

slide39

// 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”

39

Main Index

Contents

slide40

. . .

private:

int hour, minute; // data members

void normalizeTime(); // put time units in range

};

CLASS time24

Declaration

“d_time24.h”

40

Main Index

Contents

slide41

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”

41

Main Index

Contents

slide42

private:

int hour, minute; // data members

void normalizeTime(); // put time units in range

};

CLASS time24

Declaration - I/O operators

“d_time24.h”

42

Main Index

Contents

member function overloading
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

member function overloading implementation
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;

}

summary slide 1

45

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
summary slide 2

46

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.

summary slide 3

47

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.

summary slide 4

48

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.

summary slide 4a

49

Main Index

Contents

Summary Slide 4a

§- The design phase cont - Create the declaration of the classes including their attributes and public member functions. §-Describe how the classes are related to each other

- Design the algorithms that allow the classes to effectively interact.

summary slide 5

50

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.

summary slide 6

51

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.

summary slide 7

52

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.

summary slide 8

53

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.
summary slide 9

54

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.

summary slide 9a

55

Main Index

Contents

Summary Slide 9a

§-catch

- The exception handler.

- Outputs an error message and either takes corrective action or terminates the program.

summary slide 9b

56

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.

summary slide 10

57

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.

summary slide 11

58

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.

summary slide 12

59

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.