2object-oriented program development using c++ 3 relational expressions decision-making: comparison...

2Object-Oriented Program Development Using C++


Relational Expressions

• Decision-making: comparison of two numerical values• Relational expression

– Also known as a condition

– Evaluates to 1 (true) or 0 (false)

– Simple type: two operands and relational operator

• Six relational operators: <, >, <=, >=, = =, !=• Char type coerced to int for comparison• Strings compared at character level


Figure 5-1Anatomy of a Simple Relational Expression


Table 5-1Relational Operators for Primitive Data Types


Logical Operators• Complex expressions

– Comprised of simple relational expressions– Logical connectors required

• AND ( && ), OR ( | | ), NOT (!)

• Precedence– AND and OR lower than relational operators– NOT (unary) higher than relational operators

• Associativity– AND and OR: left to right– NOT: right to left


Table 5-2Operator Precedence


Table 5-3Equivalent Expressions


A Numerical Accuracy Problem

• Caveat: equality comparison of floating-point types– Avoid use of equality operator

– Computer representation slightly inaccurate

• Work around problem– If possible, replace floating-point data with integers

– If not, use alternative syntax• abs (operandOne - operandTwo) < EPSILON

• EPSILON is very small value such as .0000001


The if-else Statement• if-else statement: fundamental selection structure• Purpose: alter instruction sequence • Syntax:

if (expression) statement1;else statement2;

• Expression – Relational expression– May consist of single variable, such as type bool


Figure 5-2The if-else Flowchart


Compound Statements• Compound statement

– Sequence of statements enclosed by braces– Supports construction of complex selection structures

• Syntax: if (expression){ //sequence of statements } else{

//sequence of statements }


Block Scope

• Code block– Set of compound statements

– May be nested

• Variable scope– Variable meaningful between closing braces

– Name conflict resolved by location• Inner block takes precedence over outer

• Compiler seeks declaration moving inside out


One-Way Selection

• One-way selection: excludes else portion• Syntax:

if (expression)

statement; // code block might follow

• Non-zero expression triggers statement execution


Figure 5-3Flowchart for the One-Way if Statement


Problems Associated with the if-else Statement

• Semantic problems– Logical form

– Correct by reviewing original design

• Syntax problems– Misuse of assignment operator (=) in expression

• Assigns value to operand

• Non-zero assignments always evaluate to true

– Use equality operator (= =) for comparisons


Nested if Statements

• Selection structures may be nested – if or if-else statements nest in either (or both) parts

of larger if-else statement

– Nesting may be deeper than one level

• Syntax caveat– Use braces to define logical unit

– Misused (or missing) braces may cause fatal logical error


Figure 5-4a The if-else Nested Within the if Part


Figure 5-4bThe if-else Nested Within the else Part


The if-else chain• if-else chain: useful, readable form of nesting• Syntax:

if (expression1)

statement1; // may be code block

else if (expression2)


else


• Additional else-if components may be added


The Switch Statement

• Switch statement– Variation on chained if-else statement

– Control “switches” to case based on condition

– Caveat: condition evaluates to an integer

• Cases may include complex structures• Break statement follows each case• Default statement is optional


Figure 5-5The Expression Determines an Entry Point


Program Design and Development: Introduction to UML

• Think and plan before coding– Primary concern: classes and objects needed

• Uniform Modeling Language (UML)– Supports object-oriented design– Set of rules and diagrams

• Focus on four UML diagrams– Class, object, state, and sequence– Analogy to specialized blueprints


Figure 5-7Basic UML Symbols and Notation


Class and Object Diagrams

• Commonality of class and object diagrams– Both employ rectangular containers

– Names, attributes, behaviors found in both

• Chief differences– Class diagram: describes classes and relationships

– Object diagram: describes objects and relationships

– Class at higher level of abstraction

– One class can generate many particular objects


Figure 5-6A Class and Object Representation


Figure 5-8 Including Attributes in UML Class and Object Diagrams


Class and Object Diagrams (continued)

• Two aspects to class attributes – Data type: may be primitive or class – Visibility: where variable may be seen (or used)

• Plus (+) sign indicates public • Minus (-) sign indicates private• No sign for protected status

• Operations– Become methods that transform attributes– Follow attribute sign convention for visibility


Figure 5-9 A Class with Attributes


Figure 5-10 Including Operations in Class Diagrams


Relationships• Three basic relationships

– Association, aggregation, generalization • Association

– Signified by phrases such as “works for”, “has a” – Indicated by straight line connecting classes/

objects– Multiplicity

• Numerical relationship between objects/classes • Quantities: 0, 1, many, unlimited


Figure 5-11 An Association


Table 5-4 UML Association Notation


Relationships (continued)

• Aggregation– One class/object consists of other classes/objects

– Visualize as relation of whole to parts

– Symbolized by diamond

• Generalization– Relationship between class and its refinement

– Ford Taurus is a type of automobile


Figure 5-12 Single-Level Aggregation


Figure 5-13 Another Single-Level Aggregation


Figure 5-14 Multi-Level Aggregation


Figure 5-15 A Generalization Relationship


Application: A Date Class

• Stage one: identify and name objects• Stage two

– Define attributes• Month, day, and year

• Integer data types

• Stage three– Create object diagram

– Object diagram shows assignment of values


Figure 5-16 Initial Date Class Diagram


Figure 5-17 First Refinement-Date Class Diagram


Figure 5-18 A Date Object Diagram


Application: A Date Class (continued)

• Stage four– Identify operations that become methods– Basic operations: constructor, mutator, accessor– Additional operations: queries with comparisons

• Stage five– Construct second refinement of class diagram– Name, attributes, operations detailed– Visibility denoted


Table 5-5 Required Operations for the Date Class


Figure 5-19 Second Refinement-Date Class Diagram


Explanation of the Basic Date Class

• Default constructor– Initializes month, day, year

– cout object echo prints default data

• Overloaded constructor– Initializes Date object with parameterized interface

– cout object echo prints default data

• setDate( ): almost identical to overloaded constructor

• showDate( ): accessor manipulates output stream


Using the Basic Date Class

• Constructors instantiate two Date objects• Syntax of object declaration

– If default constructor used, follow primitive form

– If overloaded constructor used, supply arguments

• Accessors retrieve data in attributes• Output modified according to current values


Simplifying the Code

• Opportunities for optimization exist• Call internal methods when possible

– Eliminate redundant code

– Do not reinvent your own wheel

– Example: call setDate( ) in constructors

• Dealing with other redundancies – Target common or repeated actions

– Fold action into method


Adding Additional Class Methods

• Virtue of OO programming: scalability• Add isLeapYear ( )

– Based on leap year algorithm

– Returns a Boolean value

• Add dayOfWeek ( )– Based on Zeller’s algorithm

– Returns an integer value

• Include appropriate declarations, definition, visibility


A Closer Look at Program Testing

• Added complexity increases likelihood of errors• Selection structures introduce new control paths

– Ideally, programmer tests each path

– Not physically possible

– Growth of test paths: 2n

– n corresponds to number of if-else statements

• Choose critical elements to test– Legal and limiting input values


Summary

• Relational expression (condition) evaluates to 1 (true) or 0 (false)

• Relational operators: <, >, <=, >=, = =, !=• Logical connectors: AND (&&), OR (| |), NOT (!)• Basic selection structure: if-else statement• Compound statement: set enclosed by braces


Summary (continued)

• Selection variations: nesting, chained if-else, switch• Uniform Modeling Language (UML): OO design

rules/templates• Basic UML diagrams: class, object, state, sequence • Use UML tools to construct/implement Date class• Testing: selectivity avoids combinatorial explosion

2object-oriented program development using c++ 3 relational expressions decision-making: comparison...

Documents