Data Structures Using C++ 2E

Chapter 1
Software Engineering Principles and C+
+ Classes
 Software Life Cycle

• Program life cycle

– Many phases between program conception and
retirement
– Three fundamental stages
• Development, use, and maintenance
• Program retirement
– Program too expensive to maintain
• No new version released
• Software development phase
– First and most important software life cycle phase
Data Structures Using C++ 2E 2
 Software Development Phase
• Four phases
– Analysis
– Design
– Implementation
– Testing and debugging
• Analysis
– First and most important step
– Analysis requirements
• Thoroughly understand the problem
• Understand the problem requirements
• Divide problem into subproblems (if complex)
Data Structures Using C++ 2E 3
Software Development Phase (cont’d.)

• Design
– Design an algorithm to solve the problem or
subproblem
– Algorithm
• Step-by-step problem-solving process
• Solution obtained in finite amount of time
– Structured design
• Dividing problem into smaller subproblems
• Also known as: top-down design, stepwise refinement,
and modular programming

Data Structures Using C++ 2E 4

Software Development Phase (cont’d.)

• Design (cont’d.)
– Object-oriented design (OOD)
• Identifies components called objects
• Determines how objects interact with one another
• Object specifications: relevant data; possible
operations performed on that data
– Object-oriented programming (OOP) language
• Programming language implementing OOD
– Object-oriented design principles
• Encapsulation, inheritance, and polymorphism

Data Structures Using C++ 2E 5

Software Development Phase (cont’d.)
• Implementation
– Write and compile programming code
• Implement classes and functions discovered in the design
phase
– Final program consists of several functions
• Each accomplishes a specific goal
– Precondition
• Statement specifying condition(s)
• Must be true before function called
– Postcondition
• Statement specifying true items after function call completed

Data Structures Using C++ 2E 6

Software Development Phase (cont’d.)
• Testing and debugging
– Testing
• Testing program correctness
• Verifying program works properly
– Increase program reliability
• Discover and fix errors before releasing to user
– Test case
• Set of inputs, user actions, other initial conditions, and
the expected output
• Document properly
– Black-box testing and white-box testing

Data Structures Using C++ 2E 7

Algorithm Analysis: The Big-O Notation

• Analyze algorithm after design

• Example
– 50 packages delivered to 50 different houses
– 50 houses one mile apart, in the same area

FIGURE 1-1 Gift shop and each dot representing a house

Data Structures Using C++ 2E 8

Algorithm Analysis: The Big-O Notation
(cont’d.)
• Example (cont’d.)
– Driver picks up all 50 packages
– Drives one mile to first house, delivers first package
– Drives another mile, delivers second package
– Drives another mile, delivers third package, and so on
– Distance driven to deliver packages
• 1+1+1+… +1 = 50 miles
– Total distance traveled: 50 + 50 = 100 miles

FIGURE 1-2 Package delivering scheme

Data Structures Using C++ 2E 9
Algorithm Analysis: The Big-O Notation
(cont’d.)
• Example (cont’d.)
– Similar route to deliver another set of 50 packages
• Driver picks up first package, drives one mile to the first house, delivers package,
returns to the shop
• Driver picks up second package, drives two miles, delivers second package, returns to
the shop
– Total distance traveled
• 2 * (1+2+3+…+50) = 2550 miles

FIGURE 1-3 Another package delivery scheme

Data Structures Using C++ 2E 10
Algorithm Analysis: The Big-O Notation
(cont’d.)
• Example (cont’d.)
– n packages to deliver to n houses, each one mile
apart
– First scheme: total distance traveled
• 1+1+1+… +n = 2n miles
• Function of n
– Second scheme: total distance traveled
• 2 * (1+2+3+…+n) = 2*(n(n+1) / 2) = n2+n
• Function of n2

Data Structures Using C++ 2E 11

Algorithm Analysis: The Big-O Notation
(cont’d.)
• Analyzing an algorithm
– Count number of operations performed
• Not affected by computer speed

TABLE 1-1 Various values of n, 2n, n2, and n2 + n

Data Structures Using C++ 2E 12

Algorithm Analysis: The Big-O Notation
(cont’d.)
• Example 1-1
– Illustrates fixed number of executed operations

Data Structures Using C++ 2E 13

Algorithm Analysis: The Big-O Notation
(cont’d.)
• Example 1-2
– Illustrates dominant operations

Data Structures Using C++ 2E 14

Algorithm Analysis: The Big-O Notation
(cont’d.)
• Search algorithm
– n: represents list size
– f(n): count function
• Number of comparisons in search algorithm
– c: units of computer time to execute one operation
– cf(n): computer time to execute f(n) operations
– Constant c depends computer speed (varies)
– f(n): number of basic operations (constant)
– Determine algorithm efficiency
• Knowing how function f(n) grows as problem size grows

Data Structures Using C++ 2E 15

Algorithm Analysis: The Big-O Notation
(cont’d.)

TABLE 1-2 Growth rates of various functions

Data Structures Using C++ 2E 16

 Algorithm Analysis: The Big-O Notation
(cont’d.)
TABLE 1-3 Time for f(n) instructions
on a computer that executes 1 billion
instructions per second

Figure 1-4 Growth rate

of functions in Table 1-3
Data Structures Using C++ 2E 17
Algorithm Analysis: The Big-O Notation
(cont’d.)
• Notation useful in describing algorithm behavior
– Shows how a function f(n) grows as n increases
without bound
• Asymptotic
– Study of the function f as n becomes larger and larger
without bound
– Examples of functions
• g(n)=n2 (no linear term)
• f(n)=n2 + 4n + 20

Data Structures Using C++ 2E 18

Algorithm Analysis: The Big-O Notation
(cont’d.)
• As n becomes larger and larger
– Term 4n + 20 in f(n) becomes insignificant
– Term n2 becomes dominant term

TABLE 1-4 Growth rate of n2 and n2 + 4n + 20n

Data Structures Using C++ 2E 19

Algorithm Analysis: The Big-O Notation
(cont’d.)
• Algorithm analysis
– If function complexity can be described by complexity
of a quadratic function without the linear term
• We say the function is of O(n2) or Big-O of n2
• Let f and g be real-valued functions
– Assume f and g nonnegative
• For all real numbers n, f(n) >= 0 and g(n) >= 0
• f(n) is Big-O of g(n): written f(n) = O(g(n))
– If there exists positive constants c and n0 such that
f(n) <= cg(n) for all n >= n0

Data Structures Using C++ 2E 20

Algorithm Analysis: The Big-O Notation
(cont’d.)
TABLE 1-5 Some Big-O functions that appear in algorithm analysis

Data Structures Using C++ 2E 21

 Classes

• OOD first step: identify components (objects)

• Encapsulation: object combines data and data
operations in a single unit
• Class: collection of a fixed number of components
– Class members: class components
– Class member categories
• Private, public, protected

Data Structures Using C++ 2E 22

 Classes (cont’d.)
• Constructors
– Declared variable not automatically initialized
– With parameters or without parameters (default
constructor)
– Properties
• Constructor name equals class name
• Constructor has no type
• All class constructors have the same name
• Multiple constructors: different formal parameter lists
• Execute automatically: when class object enters its scope
• Execution: depends on values passed to class object

Data Structures Using C++ 2E 23

 Classes (cont’d.)
• Unified Modeling Language diagrams
– Graphical notation describing a class and its
members
– Private and public members

FIGURE 1-5 UML class diagram of the class clockType

Data Structures Using C++ 2E 24
 Classes (cont’d.)
• Variable (object) declaration
– Once class defined
• Variable declaration of that type allowed
– Class variable
• Called class object, class instance, object in C++
– A class can have both types of constructors
– Upon declaring a class object
• Default constructor executes or constructor with
parameters executes

Data Structures Using C++ 2E 25

 Classes (cont’d.)
• Accessing class members
– When an object of a class is declared
• Object can access class members
– Member access operator
• The dot, . (period)
– Class object accessed by class members
• Dependent on where object declared

Data Structures Using C++ 2E 26

 Classes (cont’d.)

• Implementation of member functions

– Reasons function prototype often included for
member functions
• Function definition can be long, difficult to comprehend
• Providing function prototypes hides data operation
details
– Writing definitions of member functions
• Use scope resolution operator, :: (double colon), to
reference identifiers local to the class

Data Structures Using C++ 2E 27

 Classes (cont’d.)

• Implementation of member functions (cont’d.)

– Example: definition of the function setTime

Data Structures Using C++ 2E 28

 Classes (cont’d.)

• Implementation of member functions (cont’d.)

• Execute statement
myClock.setTime(3,48,52);

FIGURE 1-6 Object myClock after the statement

myClock.setTime(3, 48, 52); executes

Data Structures Using C++ 2E 29

 Classes (cont’d.)

• Implementation of member functions (cont’d.)

– Example: definition of the function equalTime

Data Structures Using C++ 2E 30

 Classes (cont’d.)

• Implementation of member functions (cont’d.)

– Objects of type clockType
• myClock and yourClock

FIGURE 1-7 Objects myClock and yourClock

Data Structures Using C++ 2E 31

 Classes (cont’d.)
• Implementation of member functions (cont’d.)
if(myClock.equalTime(yourClock)) …
• Object myClock accesses member function
equalTime
• otherClock is a reference parameter
• Address of actual parameter yourClock passed to the
formal parameter otherClock

FIGURE 1-8 Object myClock and parameter otherClock

Data Structures Using C++ 2E 32
 Classes (cont’d.)

• Implementation of member functions (cont’d.)

– equalTime execution
– Variables hr , min , sec in equalTime function body
• Instance variables of variable myClock
– Once class properly defined, implemented
• Can be used in a program
– Client
• Program or software using and manipulating class
objects
– Instance variables
• Have own instance of data
Data Structures Using C++ 2E 33
 Classes (cont’d.)

• Reference parameters and class objects (variables)

– Variable passed by value
• Formal parameter copies value of the actual parameter
– Variables requiring large amount of memory and
needing to pass a variable by value
• Corresponding formal parameter receives copy of the
data of the variable
– Variable passed by reference
• Corresponding formal parameter receives only the
address of the actual parameter

Data Structures Using C++ 2E 34

 Classes (cont’d.)

• Reference parameters and class objects (variables)

(cont’d.)
– Declaring class object as a value parameter
• Declare as a reference parameter using the keyword
const
– If the formal parameter is a value parameter
• Can change the value within function definition
– If formal parameter is a constant reference parameter
• Cannot change value within the function
• Cannot use any other function to change its value

Data Structures Using C++ 2E 35

 Classes (cont’d.)

• Reference parameters and class objects (variables)

(cont’d.)
– Two built-in operations
• Member access (.)
• Assignment (=)
• Assignment operator and classes
– Assignment statement performs a memberwise copy
– Example: myClock = yourClock;
• Values of the three instance variables of yourClock
• Copied into corresponding instance variables of
myClock
Data Structures Using C++ 2E 36
 Classes (cont’d.)
• Class scope
– Automatic
• Created each time control reaches declaration
• Destroyed when control exits surrounding block
– Static
• Created once when control reaches declaration
• Destroyed when program terminates
– Can declare an array of class objects: same scope
– Member of a class: local to the class
– Access (public) class member outside the class
• Use class object name, member access operator (.)
Data Structures Using C++ 2E 37
 Classes (cont’d.)

• Functions and classes

– Rules
• Class objects passed as parameters to functions and
returned as function values
• Class objects passed either by value or reference as
parameters to functions
• Class objects passed by value: instance variables of
the actual parameter contents copied into the
corresponding formal parameter instance variables

Data Structures Using C++ 2E 38

 Classes (cont’d.)

• Constructors and default parameters

– Constructor can have default parameters
– Rules declaring formal parameters
• Same as declaring function default formal parameters
– Actual parameters passed with default parameters
• Use rules for functions with default parameters
– Default constructor
• No parameters or all default parameters

Data Structures Using C++ 2E 39

 Classes (cont’d.)

• Destructors
– Functions
– No type
– Neither value-returning nor void function
– One destructor per class
• No parameters
– Name
• Tilde character (~) followed by class name
– Automatically executes
• When class object goes out of scope

Data Structures Using C++ 2E 40

 Classes (cont’d.)

• Structs
– Special type of classes
– All struct members public
– C++ defines structs using the reserved word struct
– If all members of a class are public, C++
programmers prefer using struct to group the
members
– Defined like a class

Data Structures Using C++ 2E 41

 Data Abstraction, Classes, and
Abstract Data Types
• Abstraction
– Separating design details from use
• Data abstraction
– Process
• Separating logical data properties from implementation
details
• Abstract data type (ADT)
– Data type separating logical properties from
implementation details
– Includes type name, domain, set of data operations

Data Structures Using C++ 2E 42

 Data Abstraction, Classes, and
Abstract Data Types (cont’d.)
• ADT
– Example: defining the clockType ADT

Data Structures Using C++ 2E 43

 Data Abstraction, Classes, and
Abstract Data Types (cont’d.)
• Implementing an ADT
– Represent the data; write algorithms to perform
operations
– C++ classes specifically designed to handle ADTs

Data Structures Using C++ 2E 44

 Identifying Classes, Objects, and
Operations
• Object-oriented design
– Hardest part
• Identifying classes and objects
• Technique to identify classes and objects
– Begin with problem description
– Identify all nouns and verbs
• From noun list: choose classes
• From verb list: choose operations

Data Structures Using C++ 2E 45

 Summary
• Program life cycle software development phases
– Analysis, design, implementation, testing, and
debugging
• Algorithm: step-by-step problem-solving process
– Solution obtained in finite amount of time
• Object-oriented design principles
– Encapsulation, inheritance, and polymorphism
• Constructors guarantee class instance variables
initialized
• UML diagrams: graphical notation describing class
and its members
Data Structures Using C++ 2E 46
 Summary (cont’d.)

• Data abstraction
– Separating logical data properties from
implementation details
• Class: collection of fixed number of components
• Components called members
• Destructors: functions without a type
• Structs: special type of classes
• Abstract data type (ADT)
– Data type separating logical properties from
implementation details
Data Structures Using C++ 2E 47