Object Oriented Programming Using C++ ppt

Object-Oriented

Programming

Using C++

Fourth Edition

Joyce Farrell

Australia • Brazil • Japan • Korea • Mexico • Singapore • Spain • United Kingdom • United States

Object-Oriented Programming

Using C++, Fourth Edition

Joyce Farrell

Executive Editor: Marie Lee

Acquisitions Editor: Amy Jollymore

Managing Editor: Tricia Coia

Developmental Editor: Lisa Ruffolo

Editorial Assistant: Patrick Frank

Marketing Manager: Bryant Chrzan

Content Project Manager: Erin Dowler

Art Director: Bruce Bond

Manufacturing Coordinator:

Julio Esperas

Proofreader: Wendy Benedetto

Cover Designer: Bruce Bond

Cover Photo: © iStockphoto.com/

Storman

Compositor: International Typesetting

and Composition

© 2009 Course Technology, Cengage Learning

ALL RIGHTS RESERVED. No part of this work covered by the copyright

herein may be reproduced, transmitted, stored or used in any form or by

any means—graphic, electronic, or mechanical, including but not limited

to photocopying, recording, scanning, digitizing, taping, Web distribution,

information networks, or information storage and retrieval systems, except

as permitted under Section 107 or 108 of the 1976 United States

Copyright Act—without the prior written permission of the publisher.

For product information and technology assistance, contact us at

Cengage Learning Customer & Sales Support, 1-800-354-9706

For permission to use material from this text or product,

submit all requests online at cengage.com/permissions

Further permissions questions can be e-mailed to

[email protected]

ISBN-13: 978-1-4239-0257-7

ISBN-10: 1-4239-0257-2

Course Technology

25 Thomson Place

Boston, MA 02210

USA

Cengage Learning is a leading provider of customized learning solutions with

office locations around the globe, including Singapore, the United Kingdom,

Australia, Mexico, Brazil, and Japan. Locate your local office at:

international.cengage.com/region

Cengage Learning products are represented in Canada by Nelson

Education, Ltd.

For your lifelong learning solutions, visit course.cengage.com

Purchase any of our products at your local college store or at our

preferred online store www.ichapters.com

Some of the product names and company names used in this book have

been used for identification purposes only and may be trademarks or

registered trademarks of their respective manufacturers and sellers.

Course Technology, a part of Cengage Learning, reserves the right to

revise this publication and make changes from time to time in its content

without notice.

Printed in the United States of America

1 2 3 4 5 6 7 12 11 10 09 08

BRIEF CONTENTS

PREFACE xvii

READ THIS BEFORE YOU BEGIN xxi

CHAPTER 1 AN OVERVIEW OF OBJECT-ORIENTED PROGRAMMING

AND C++ 1

CHAPTER 2 EVALUATING C++ EXPRESSIONS 51

CHAPTER 3 MAKING DECISIONS 81

CHAPTER 4 PERFORMING LOOPS 123

CHAPTER 5 UNDERSTANDING ARRAYS, STRINGS, AND POINTERS 165

CHAPTER 6 USING C++ FUNCTIONS 223

CHAPTER 7 USING CLASSES 283

CHAPTER 8 CLASS FEATURES AND DESIGN ISSUES 333

CHAPTER 9 UNDERSTANDING FRIENDS AND OVERLOADING OPERATORS 385

CHAPTER 10 UNDERSTANDING INHERITANCE 451

CHAPTER 11 USING TEMPLATES 501

CHAPTER 12 HANDLING EXCEPTIONS 557

CHAPTER 13 ADVANCED INPUT AND OUTPUT 615

CHAPTER 14 ADVANCED TOPICS 673

APPENDIX A GETTING STARTED WITH MICROSOFT VISUAL STUDIO 2008 731

APPENDIX B GETTING STARTED WITH OTHER C++ COMPILERS 737

APPENDIX C OPERATOR PRECEDENCE AND ASSOCIATIVITY 745

APPENDIX D FORMATTING OUTPUT 749

APPENDIX E GENERATING RANDOM NUMBERS 755

GLOSSARY 761

INDEX 777

iii

This page intentionally left blank

CONTENTS

PREFACE xvii

READ THIS BEFORE YOU BEGIN xxi

CHAPTER 1 AN OVERVIEW OF OBJECT-ORIENTED PROGRAMMING

AND C++ 1

THE TASK OF PROGRAMMING 2

PROGRAMMING UNIVERSALS 3

PROCEDURAL PROGRAMMING 5

Early Procedural Programs 5

Modularity and Abstraction 7

Encapsulation 10

OBJECT-ORIENTED PROGRAMMING 11

Objects and Classes 11

Inheritance 12

Polymorphism 13

GETTING STARTED IN THE C++ PROGRAMMING ENVIRONMENT 13

Creating a main()Function 14

WORKING WITH VARIABLES AND THE const QUALIFIER 16

The int Data Type 18

The char Data Type 18

The bool Data Type 19

Floating-Point Data Types 19

Declaring Variables 19

The const Qualifier 21

CREATING COMMENTS 22

ANSI/ISO STANDARD C++ 23

Using Libraries, Preprocessor Directives, and namespace 24

PRODUCING C++ OUTPUT 25

PROVIDING C++ INPUT 27

A FIRST LOOK AT DATA STRUCTURES AND CLASSES 29

YOU DO IT 32

Creating a Program That Displays Variable Values 32

Introducing Errors into a Program 34

Modifying a Program to Accept Input Values 35

Creating a Simple Structure 36

v

CONTENTS

CHAPTER SUMMARY 37

KEY TERMS 38

REVIEW QUESTIONS 43

EXERCISES 45

CASE PROJECT 1 48

CASE PROJECT 2 48

UP FOR DISCUSSION 49

CHAPTER 2 EVALUATING C++ EXPRESSIONS 51

USING C++ BINARY ARITHMETIC OPERATORS 52

Using Modulus 56

PRECEDENCE AND ASSOCIATIVITY OF ARITHMETIC OPERATIONS 58

SHORTCUT ARITHMETIC OPERATORS 59

Compound Assignment Operators 59

Increment and Decrement Operators 60

OTHER UNARY OPERATORS 61

EVALUATING BOOLEAN EXPRESSIONS 63

PERFORMING OPERATIONS ON STRUCT FIELDS 65

YOU DO IT 67

Using Arithmetic Operators 67

Using Prefix and Postfix Increment and Decrement Operators 68

Using Operators with struct Fields 69

CHAPTER SUMMARY 71

KEY TERMS 71

REVIEW QUESTIONS 73

EXERCISES 75

CASE PROJECT 1 78

CASE PROJECT 2 78

UP FOR DISCUSSION 79

CHAPTER 3 MAKING DECISIONS 81

USING THE IF STATEMENT 82

The Single-Alternative if 82

The Dual-Alternative if 85

USING A NESTED IF 87

AVOIDING COMMON PITFALLS WITH IF STATEMENTS 89

Pitfall: Forgetting that C++ Comparisons are Case Sensitive 89

Pitfalls: Assuming that indentation has a logical purpose, adding

an Unwanted Semicolon, and Forgetting Curly Braces 90

vi

CONTENTS

Pitfall: Using = Instead of == 91

Pitfall: Making Unnecessary Comparisons 93

Pitfall: Creating Unreachable Code 94

USING THE SWITCH STATEMENT 96

USING THE CONDITIONAL OPERATOR 99

USING THE LOGICAL AND AND OR OPERATORS 100

Using the Logical AND Operator 100

Using the Logical OR Operator 102

Pitfall: Using OR When You Mean AND 104

Combining AND and OR Selections 104

MAKING DECISIONS WITH STRUCTURE FIELDS 105

YOU DO IT 107

Using a Single-Alternative if 107

Using a Dual-Alternative if 108

Using a Compound Condition and Nested ifs 109

CHAPTER SUMMARY 111

KEY TERMS 112

REVIEW QUESTIONS 113

EXERCISES 117

CASE PROJECT 1 121

CASE PROJECT 2 121

UP FOR DISCUSSION 122

CHAPTER 4 PERFORMING LOOPS 123

THE while LOOP 124

WRITING TYPICAL LOOPS 127

A Typical Loop: Input Verification 127

A Typical Loop: Reading Input Records 128

AVOIDING COMMON PITFALLS WITH LOOPS 130

Pitfall: Adding an Unwanted Semicolon 131

Pitfalls: Forgetting Curly Braces or Forgetting to Alter a Loop Control Variable 132

Pitfall: Failing to Initialize a Loop Control Variable 133

ACCUMULATING TOTALS 135

THE FOR LOOP 136

PRETEST VS. POSTTEST LOOPS 139

NESTED LOOPS 143

USING LOOPS WITH STRUCTURE FIELDS 145

YOU DO IT 149

Using a Loop to Validate User Data Entry 149

Using a Structure in an Application Containing Several Loops 150

vii

CONTENTS

CHAPTER SUMMARY 154

KEY TERMS 155

REVIEW QUESTIONS 155

EXERCISES 159

CASE PROJECT 1 161

CASE PROJECT 2 162

UP FOR DISCUSSION 163

CHAPTER 5 UNDERSTANDING ARRAYS, STRINGS, AND POINTERS 165

UNDERSTANDING MEMORY ADDRESSES 166

UNDERSTANDING ARRAYS 167

STORING VALUES IN AN ARRAY 170

ACCESSING AND USING ARRAY VALUES 172

AVOIDING COMMON ARRAY ERRORS 175

Pitfall: Forgetting that Arrays are Zero-Based 175

Pitfall: Accessing Locations Beyond the Array 176

USING PART OF AN ARRAY 177

USING PARALLEL ARRAYS 180

CREATING ARRAYS OF STRUCTURE OBJECTS 183

USING TWO-DIMENSIONAL ARRAYS 185

USING CHARACTER ARRAY STRINGS 188

Strings Created as Arrays of Characters 189

Special String-Handling Problems When Using

Character Arrays 190

AN INTRODUCTION TO THE STRING CLASS 197

USING POINTERS 200

USING A POINTER INSTEAD OF AN ARRAY NAME 201

YOU DO IT 205

Using an Array 205

Understanding Memory Addresses 208

CHAPTER SUMMARY 210

KEY TERMS 211

REVIEW QUESTIONS 212

EXERCISES 215

CASE PROJECT 1 220

CASE PROJECT 2 220

UP FOR DISCUSSION 221

viii

CONTENTS

CHAPTER 6 USING C++ FUNCTIONS 223

WRITING SIMPLE FUNCTIONS 224

PLACING FUNCTIONS WITHIN FILES 226

Placing a Function as Part of the Same File, Before main() 226

Placing a Function as Part of the Same File, After main() 228

Placing a Function in Its Own File 230

UNDERSTANDING PROCEDURAL ABSTRACTION 232

UNDERSTANDING SCOPE 234

Distinguishing Between Local and Global Variables 234

Using the Scope Resolution Operator 237

RETURNING VALUES FROM FUNCTIONS 239

PASSING VALUES TO FUNCTIONS 243

AVOIDING COMMON ERRORS WHEN USING FUNCTIONS 246

Pitfall: Neglecting to Make Sure the Function Declaration, Header, and Call Agree 246

Pitfall: Indicating an Argument Type in a Function Call 247

Pitfall: Indicating a Return Type in a Function Call 247

Pitfall: Ignoring the Order of Parameters 247

Pitfall: Assuming that an Unused Return Value Has an Effect 248

USING OBJECTS AS PARAMETERS TO,

AND AS RETURN TYPES OF, FUNCTIONS 248

PASSING ADDRESSES TO FUNCTIONS 250

USING REFERENCE VARIABLES WITH FUNCTIONS 253

Declaring Reference Variables 253

Passing Variable Addresses to Reference Variables 255

PASSING ARRAYS TO FUNCTIONS 258

USING INLINE FUNCTIONS 260

USING DEFAULT PARAMETERS 262

OVERLOADING FUNCTIONS 264

Avoiding Ambiguity 266

YOU DO IT 267

Writing Functions That Return Values 267

Writing a Function That Requires a Parameter 269

CHAPTER SUMMARY 270

KEY TERMS 271

REVIEW QUESTIONS 273

EXERCISES 276

CASE PROJECT 1 281

CASE PROJECT 2 281

UP FOR DISCUSSION 282

ix

CONTENTS

CHAPTER 7 USING CLASSES 283

CREATING CLASSES 284

ENCAPSULATING CLASS COMPONENTS 286

Designing Classes 287

IMPLEMENTING FUNCTIONS IN A CLASS 289

Using Public Functions to Alter Private Data 290

UNUSUAL USE: USING PRIVATE FUNCTIONS AND PUBLIC DATA 295

CONSIDERING SCOPE WHEN DEFINING MEMBER FUNCTIONS 298

USING STATIC CLASS MEMBERS 301

Defining Static Data Members 301

Using Static Functions 305

UNDERSTANDING THE THIS POINTER 307

Using the this Pointer Explicitly 311

Using the Pointer-to-Member Operator 311

UNDERSTANDING POLYMORPHISM 313

YOU DO IT 314

Creating and Using a Class 314

Using a static Field 317

Understanding How static and Non-static Fields are Stored 320

CHAPTER SUMMARY 321

KEY TERMS 322

REVIEW QUESTIONS 323

EXERCISES 327

CASE PROJECT 1 330

CASE PROJECT 2 331

UP FOR DISCUSSION 331

CHAPTER 8 CLASS FEATURES AND DESIGN ISSUES 333

CLASSIFYING THE ROLES OF MEMBER FUNCTIONS 334

UNDERSTANDING CONSTRUCTORS 335

WRITING CONSTRUCTORS WITHOUT PARAMETERS 336

WRITING CONSTRUCTORS WITH PARAMETERS 341

Pitfall: Using Parentheses When Instantiating an Object with a Default Constructor 344

OVERLOADING CONSTRUCTORS 345

USING DESTRUCTORS 347

UNDERSTANDING COMPOSITION 352

Using Composition When Member Classes Contain Non-default Constructors 355

USING #IFNDEF, #DEFINE, AND #ENDIF 358

IMPROVING CLASSES 361

x

CONTENTS

Selecting Member Data and Function Names 361

Reducing Coupling Between Functions 363

Increasing Cohesion in a Function 363

YOU DO IT 365

Creating a Class with a Constructor 365

Using Constructor Parameters 368

Understanding Composition 369

CHAPTER SUMMARY 372

KEY TERMS 374

REVIEW QUESTIONS 375

EXERCISES 378

CASE PROJECT 1 382

CASE PROJECT 2 383

UP FOR DISCUSSION 384

CHAPTER 9 UNDERSTANDING FRIENDS AND OVERLOADING OPERATORS 385

WHAT ARE FRIENDS? 386

HOW TO DECLARE A FUNCTION AS A FRIEND 387

UNDERSTANDING THE BENEFITS OF OVERLOADING AND POLYMORPHISM 391

USING A FRIEND FUNCTION TO ACCESS DATA FROM TWO CLASSES 393

Using a Forward Declaration 395

OVERLOADING OPERATORS—THE GENERAL RULES 397

OVERLOADING AN ARITHMETIC OPERATOR 402

Paying Attention to the Order of the Operands 405

OVERLOADING AN OPERATOR TO WORK WITH

AN OBJECT AND A PRIMITIVE TYPE 406

USING MULTIPLE OPERATIONS IN AN EXPRESSION 409

OVERLOADING OUTPUT 412

OVERLOADING INPUT 416

OVERLOADING THE PREFIX ++ AND – – OPERATORS 418

USING POSTFIX INCREMENT AND DECREMENT OPERATORS 421

OVERLOADING THE == OPERATOR 422

OVERLOADING THE = OPERATOR 424

OVERLOADING [ ] AND ( ) 430

YOU DO IT 434

Overloading an Arithmetic Operator 434

Overloading an Output Operator 435

CHAPTER SUMMARY 436

KEY TERMS 438

xi

CONTENTS

REVIEW QUESTIONS 439

EXERCISES 442

CASE PROJECT 1 447

CASE PROJECT 2 448

UP FOR DISCUSSION 449

CHAPTER 10 UNDERSTANDING INHERITANCE 451

UNDERSTANDING INHERITANCE 452

UNDERSTANDING THE ADVANTAGES PROVIDED BY INHERITANCE 453

CREATING A DERIVED CLASS 454

UNDERSTANDING INHERITANCE RESTRICTIONS 458

CHOOSING THE CLASS ACCESS SPECIFIER 462

OVERRIDING INHERITED ACCESS 463

OVERRIDING AND OVERLOADING PARENT CLASS FUNCTIONS 467

PROVIDING FOR BASE CLASS CONSTRUCTION 474

USING MULTIPLE INHERITANCE 478

DISADVANTAGES OF USING MULTIPLE INHERITANCE 481

USING VIRTUAL BASE CLASSES 482

YOU DO IT 484

Creating a Base Class 484

Creating a Child Class 486

Creating Another Child Class 488

Using Multiple Inheritance 489

CHAPTER SUMMARY 491

KEY TERMS 492

REVIEW QUESTIONS 493

EXERCISES 496

CASE PROJECT 1 498

CASE PROJECT 2 499

UP FOR DISCUSSION 500

CHAPTER 11 USING TEMPLATES 501

UNDERSTANDING THE USEFULNESS OF FUNCTION TEMPLATES 502

CREATING FUNCTION TEMPLATES 504

USING MULTIPLE PARAMETERS IN FUNCTION TEMPLATES 506

OVERLOADING FUNCTION TEMPLATES 509

USING MORE THAN ONE TYPE IN A FUNCTION TEMPLATE 511

USING MORE THAN ONE PARAMETERIZED TYPE IN A FUNCTION TEMPLATE 513

xii

CONTENTS

EXPLICITLY SPECIFYING THE TYPE IN A FUNCTION TEMPLATE 516

Using Multiple Explicit Types in a Function Template 518

USING CLASS TEMPLATES 519

CREATING A COMPLETE CLASS TEMPLATE 521

UNDERSTANDING THE USEFULNESS OF CONTAINER CLASSES 523

CREATING AN ARRAY TEMPLATE CLASS 525

INTRODUCTION TO THE STANDARD TEMPLATE LIBRARY 531

Inserting a New Element into a Vector Using Iterators and the insert()Method 536

Sorting Vector Elements Using the sort()Algorithm 536

YOU DO IT 540

Creating a Function Template 540

Proving the Template Function Works with Class Objects 541

CHAPTER SUMMARY 544

KEY TERMS 546

REVIEW QUESTIONS 547

EXERCISES 550

CASE PROJECT 1 553

CASE PROJECT 2 554

UP FOR DISCUSSION 555

CHAPTER 12 HANDLING EXCEPTIONS 557

UNDERSTANDING THE LIMITATIONS OF TRADITIONAL ERROR HANDLING METHODS 558

THROWING EXCEPTIONS 560

USING TRY BLOCKS 563

CATCHING EXCEPTIONS 564

USING MULTIPLE THROW STATEMENTS AND MULTIPLE CATCH BLOCKS 566

Determining the Order of catch Blocks 568

USING THE DEFAULT EXCEPTION HANDLER 569

UNDERSTANDING EXCEPTION CLASSES IN THE STANDARD RUNTIME LIBRARY 570

An Example of an Automatically Thrown logic_error 571

Using the what()Function 573

Explicitly Throwing a Built-in exception 573

DERIVING YOUR OWN EXCEPTIONS FROM THE EXCEPTION CLASS 576

Overriding the Exception Class what()Function 580

USING EXCEPTION SPECIFICATIONS 582

Exception Specifications in ANSI C++ 582

How Visual C++ Departs from the ANSI Standard 583

UNWINDING THE STACK 583

RETHROWING EXCEPTIONS 589

xiii

CONTENTS

HANDLING MEMORY ALLOCATION EXCEPTIONS 591

WHEN TO USE EXCEPTION HANDLING 593

YOU DO IT 594

Creating a Typical Data Entry Application 594

Modifying the SimpleDataEntry Program to Throw an Exception 595

Creating a Custom Exception Class 597

Throwing and Catching Multiple Exceptions 599

Using a Generic catch Block 602

CHAPTER SUMMARY 603

KEY TERMS 605

REVIEW QUESTIONS 606

EXERCISES 609

CASE PROJECT 1 613

CASE PROJECT 2 613

UP FOR DISCUSSION 614

CHAPTER 13 ADVANCED INPUT AND OUTPUT 615

UNDERSTANDING CIN AND COUT AS OBJECTS 616

USING ISTREAM MEMBER FUNCTIONS 618

Using the get()Function 618

Using the ignore()Function 621

Using the getline()Function 623

Other istream Member Functions 624

USING OSTREAM MEMBER FUNCTIONS 625

Using Format Flags with setf()and unsetf() 625

Using the width()Function 626

Using the precision()Function 627

Other ostream Member Functions 627

USING MANIPULATORS 628

Using the setprecision()Manipulator 629

Using the setw()Manipulator 630

Using the setiosflags()and resetiosflags()Manipulators 631

Using the oct, hex, and showbase manipulators 631

CREATING MANIPULATOR FUNCTIONS 632

UNDERSTANDING COMPUTER FILES 634

SIMPLE FILE OUTPUT 636

SIMPLE FILE INPUT 642

WRITING AND READING OBJECTS 644

WORKING WITH RANDOM ACCESS FILES 648

Setting up a File for Direct Access 650

xiv