Software Design Overview

1
Software Design Overview Software Design
Stages Program Design -The Traditional Approach
calendar Class date Class Implementing the
Calendar Class Error Handling -Program
Termination -Setting a Flag
Chapter 2 Object Design Techniques
C Exceptions Object Composition timeCard
Class Implementing timeCard Class -Constructor -
punchOut() Operator Overloading -With Free
Functions -With Friend Functions -Stream I/O
Operators Operator Functions time24 Class
Member Function Overloading -Implementation Sum
mary 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
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
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
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
Program DesignThe Traditional Approach
Contents
10
Program Design
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
11
CLASS calendar
Declaration
d_cal.h
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
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 gt
1900 private . . .
13
date Class (API)
14
date Class
15
Implementing the calendar Class
setMonth() // update the current month
void calendarsetMonth(int mm)
// verify that mm is a valid month if
(mm lt 1 mm gt 12) throw dateError("calendar
setMonth()",mm, "invalid month") //
set d to new month d.setMonth(mm)

16
Error handling Program Termination
Implementing duration() by terminating the
program in case of error time24
time24duration(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
17
Error handling Program Termination
if (tTime lt currTime) cerr ltlt
"time24 duration() argument is an earlier
time" ltlt endl exit(1) else
return time24(0, tTime-currTime)
18
Error HandlingSetting a Flag
Implementing duration() with an error
flag time24 time24duration(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 000 // is the return // time
if an error occurs time24 returnTime
19
Error HandlingSetting a Flag
// assume that no error will occur success
true // if t is earlier than the current time,
// assign false to success if (tTime lt
currTime) success false else //
successful. assign duration to //
returnTime returnTime time24(0,
tTime-currTime) return returnTime
20
Error HandlingSetting 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(nextTi
me, success) if (success
false) // check success and deal with an
error lttake appropriate
actiongt
21
C Exceptions
Contents
22
C Exceptions
Implementing duration() by throwing an
exception time24 time24duration(const time24
t) // convert current time and time t to //
minutes int currTime hour 60 minute int
tTime t.hour 60 t.minute
23
C Exceptions
// if t is earlier than the current time, //
throw an exception if (tTime lt
currTime) throw rangeError( "time24
duration() argument is an earlier
time") else return
time24(0, tTime-currTime)
24
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.

25
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,
26
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) /
27
private string workerID time24
punchInTime, punchOutTime // supplier-class
objects double payrate bool hasPunched
28
Implementing the timeCard Class Constructor
Constructor // use initialization list to
initialize // data members. timeCardtimeCard(c
onst string ssno, double rate,
int punchInHour, int
punchInMinute) workerID(ssno), payrate(rate),
hasPunched(false), punchInTime(punchInH
our, punchInMinute) )
29
Implementing the timeCard Class punchOut()
punchOut() void timeCardpunchOut(const time24
t) punchOutTime t hasPunched true
30
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()
31
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.

32
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()
33
Operator Overloading- with Free Functions

• The same comparison can be made using operator
  overloading.

bool operator (const className lhs,
const className rhs)
34
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.

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

36
Operator Overloading- Stream I/O Operators
A class can overload the stream operators ltlt and
gtgt as friend functions. operator function
prototype for each operation (Output)
ltlt friend ostream operatorltlt (ostream ostr,
const className obj) (Input) gtgt istream
operatorgtgt (istream istr, className obj)
37
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)
38
class time24 publ
ic // 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)
39
// 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 operatorlt
(const time24 lhs, const time24 rhs) . . .
40
. . . private int hour, minute
// data members void
normalizeTime() // put time units
in range
41
class time24
public . .
. // input a time for object t friend
istream operatorgtgt (istream istr,
time24 t)   // output the time in t as
// hourminute friend ostream
operatorltlt (ostream ostr, const
time24 t)
42
private int hour, minute
// data members void
normalizeTime() // put time units
in range
43
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
44
Member Function Overloading-Implementation-
// implement by using addition with //
operands this and rhs time24 time24operator
(const time24 rhs) // add this and rhs using
overloaded // operator this this
rhs // return a reference to the current //
object return this
45
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

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

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

48
Summary Slide 4

• The design phase
• - 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.
• - Create the declaration of the classes
  including their attributes and public member
  functions.
• - Describe how the classes are related
• - Design the algorithms that allow the classes
  to effectively interact.

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

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

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

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

53
Summary Slide 9

• C exceptions are handled by three keywords
  (cross your fingers)
• try
• - Function calls and code that may generate an
  exception are placed in a try block.
• catch
• -The exception handler.
• -Outputs an error message and either takes
  corrective action or terminates the program.
• throw
• -Bypasses the normal function return mechanism
  searches chain of previous function calls until
  it locates a catch block.

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

55
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 private object data
• 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.

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