Programming and Problem Solving With C++,9780763710637

Programming and Problem Solving With C++

by ; ;
ISBN13: 9780763710637
ISBN10: 0763710636
Format: Paperback
Pub. Date: 1999-08-01
Publisher(s): Jones & Bartlett Learning
List Price: $82.95

Rent Textbook

Select for Price
Add to Cart
There was a problem. Please try again later.

New Textbook

We're Sorry
Sold Out

Used Textbook

We're Sorry
Sold Out

eTextbook

We're Sorry
Not Available

Buy from our Marketplace starting at $7.55

How Marketplace Works:

  • This item is offered by an independent seller and not shipped from our warehouse
  • Item details like edition and cover design may differ from our description; see seller's comments before ordering.
  • Sellers much confirm and ship within two business days; otherwise, the order will be cancelled and refunded.
  • Marketplace purchases cannot be returned to eCampus.com. Contact the seller directly for inquiries; if no response within two days, contact customer service.
  • Additional shipping costs apply to Marketplace purchases. Review shipping costs at checkout.

Summary

Programming & Problem Solving with C++ provides the most accessible introduction to C++ & object-oriented programming for beginning students. With its straightforward & disciplined programming style, this text is free of intricate language features, promotes good programming habits, & provides clear examples, complete case studies, & numerous end-of-chapter exercises. The first half of the text gives students a solid foundation in algorithm development & functional decomposition design methodology. The second half builds on the foundation, exploring ADTs, the C++ classes, encapsulation, information hiding, & object-oriented software development.

Table of Contents

Overview of Programming and Problem Solving
1(46)
Overview of Programming
2(8)
What Is Programming?
2(1)
How Do We Write a Program?
3(5)
Theoretical Foundations: Binary Representation of Data
8(2)
What is a Programming Language?
10(6)
Background Information: Compilers and Interpreters
13(3)
What Is a Computer?
16(9)
Background Information: PCs, Workstations, and Mainframes
19(5)
Background Information: The Origins of C++
24(1)
Ethics and Responsibilities in the Computing Profession
25(5)
Software Piracy
26(1)
Privacy of Data
27(1)
Use of Computer Resources
28(1)
Software Engineering
29(1)
Problem-Solving Techniques
30(6)
Ask Questions
30(1)
Look for Things That Are Familiar
31(1)
Solve by Analogy
31(1)
Means-Ends Analysis
32(1)
Divide and Conquer
33(1)
The Building-Block Approach
34(1)
Merging Solutions
34(1)
Mental Blocks: The Fear of Starting
35(1)
Algorithmic Problem Solving
36(1)
Problem-Solving Case Study: An Algorithm for a Company Payroll
36(5)
Summary
41(6)
Quick Check
42(1)
Exam Preparation Exercises
43(1)
Programming Warm-up Exercises
44(1)
Case Study Follow-Up
45(2)
C++ Syntax and Semantics, and the Program Development Process
47(54)
The Elements of C++ Programs
48(25)
C++ Program Structure
48(3)
Syntax and Semantics
51(1)
Theoretical Foundations: Metalanguages
52(1)
Syntax Templates
53(3)
Naming Program Elements: Identifiers
56(1)
Matters of Style: Using Meaningful, Readable Identifiers
57(1)
Data and Data Types
58(1)
Background Information: Data Storage
58(3)
Naming Elements: Declarations
61(4)
Matters of Style: Capitalization of Identifiers
65(1)
Taking Action: Executable Statements
66(6)
Beyond Minimalism: Adding Comments to a Program
72(1)
Program Construction
73(8)
Blocks (Compound Statements)
75(3)
The C++ Preprocessor
78(1)
An Introduction to Namespaces
79(2)
More About Output
81(2)
Creating Blank Lines
81(1)
Inserting Blanks Within a Line
82(1)
Program Entry, Correction, and Execution
83(3)
Entering a Program
83(1)
Compiling and Running a Program
84(2)
Finishing Up
86(1)
Problem-Solving Case Study: Contest Letter
86(5)
Testing and Debugging
91(1)
Summary
92(9)
Quick Check
93(2)
Exam Preparation Exercises
95(3)
Programming Warm-up Exercises
98(1)
Programming Problems
99(1)
Case Study Follow-Up
100(1)
Numeric Types, Expressions, and Output
101(52)
Overview of C++ Data Types
102(1)
Numeric Data Types
103(2)
Integral Types
103(1)
Floating-Point Types
104(1)
Declarations for Numeric Types
105(2)
Named Constant Declarations
105(1)
Software Engineering Tip: Using Names Constants Instead of Literals
106(1)
Variable Declarations
106(1)
Simple Arithmetic Expressions
107(5)
Arithmetic Operators
107(3)
Increment and Decrement Operators
110(2)
Compound Arithmetic Expressions
112(6)
Precedence Rules
112(1)
Type Coercion and Type Casting
113(4)
May We Introduce: Blaise Pascal
117(1)
Function Calls and Library Functions
118(5)
Value-Returning Functions
118(2)
Library Functions
120(2)
Void Functions
122(1)
Formatting the Output
123(8)
Integers and Strings
123(3)
Floating-Point Numbers
126(3)
Matters of Style: Program Formatting
129(2)
Additional string Operations
131(6)
The length and size Functions
131(1)
The find Function
132(2)
The substr Function
134(2)
Software Engineering Tip: Understanding Before Changing
136(1)
Problem-Solving Case Study: Map Measurements
137(4)
Testing and Debugging
141(1)
Summary
142(11)
Quick Check
142(3)
Exam Preparation Exercises
145(3)
Programming Warm-up Exercises
148(3)
Programming Problems
151(1)
Case Study Follow-Up
152(1)
Program Input and the Software Design Process
153(58)
Getting Data into Programs
154(11)
Input Streams and the Extraction Operator (>>)
155(3)
The Reading Marker and the Newline Character
158(2)
Reading Character Data with the get Function
160(2)
Theoretical Foundations: More About Functions and Arguments
162(1)
Skipping Characters with the ignore Function
162(1)
Reading String Data
163(2)
Interactive Input/Output
165(2)
Noninteractive Input/Output
167(1)
File Input and Output
167(8)
Files
168(1)
Using Files
168(4)
An Example Program Using Files
172(2)
Run-Time Input of File Names
174(1)
Input Failure
175(2)
Software Design Methodologies
177(1)
What Are Objects?
178(1)
Object-Oriented Design
179(2)
Functional Decomposition
181(11)
Modules
182(3)
Implementing the Design
185(6)
A Perspective on Design
191(1)
Software Engineering Tip: Documentation
191(1)
Problem-Solving Case Study: Stretching a Canvas
192(8)
Background Information: Programming on Many Scales
198(2)
Testing and Debugging
200(2)
Testing and Debugging Hints
201(1)
Summary
202(9)
Quick Check
203(1)
Exam Preparation Exercises
204(2)
Programming Warm-up Exercises
206(2)
Programming Problems
208(1)
Case Study Follow-Up
209(2)
Conditions, Logical Expressions, and Selection Control Structures
211(64)
Flow of Control
212(2)
Selection
213(1)
Conditions and Logical Expressions
214(15)
The bool Data Type
214(1)
Background Information: Before the bool Type
215(1)
Logical Expressions
216(8)
May We Introduce: George Boole
224(1)
Precedence of Operators
225(2)
Software Engineering Tip: Changing English Statements into Logical Expressions
227(1)
Relational Operators with Floating-Point Types
228(1)
The If Statement
229(7)
The If-Then-Else Form
229(3)
Blocks (Compound Statements)
232(1)
Matters of Style: Braces and Blocks
233(1)
The If-Then Form
234(2)
A Common Mistake
236(1)
Nested If Statements
236(5)
The Dangling else
240(1)
Testing the State of an I/O Stream
241(2)
Problem-Solving Case Study: Warning Notices
243(6)
Testing and Debugging
249(15)
Testing in the Problem-Solving Phase: The Algorithm Walk-Through
249(4)
Testing in the Implementation Phase
253(6)
The Test Plan
259(1)
Tests Performed Automatically During Compilation and Execution
260(2)
Testing and Debugging Hints
262(2)
Summary
264(11)
Quick Check
264(1)
Exam Preparation Exercises
265(3)
Programming Warm-up Exercises
268(3)
Programming Problems
271(3)
Case Study Follow-Up
274(1)
Looping
275(50)
The While Statement
276(2)
Phases of Loop Execution
278(2)
Loops Using the While Statement
280(12)
Count-Controlled Loops
280(2)
Event-Controlled Loops
282(6)
Looping Subtasks
288(4)
How to Design Loops
292(4)
Designing the Flow of Control
292(2)
Designing the Process Within the Loop
294(1)
The Loop Exit
295(1)
Nested Logic
296(11)
Designing Nested Loops
300(2)
Theoretical Foundations: Analysis of Algorithms
302(5)
Problem-Solving Case Study: Average Income by Gender
307(6)
Testing and Debugging
313(4)
Loop-Testing Strategy
313(1)
Test Plans Involving Loops
314(1)
Testing and Debugging Hints
315(2)
Summary
317(8)
Quick Check
318(1)
Exam Preparation Exercises
318(3)
Programming Warm-up Exercises
321(1)
Programming Problems
322(2)
Case Study Follow-Up
324(1)
Functions
325(66)
Functional Decomposition with Void Functions
326(6)
When to Use Functions
327(1)
Writing Modules as Void Functions
327(4)
May We Introduce: Charles Babbage
331(1)
An Overview of User-Defined Functions
332(4)
Flow of Control in Function Calls
332(1)
Function Parameters
333(3)
Syntax and Semantics of Void Functions
336(8)
Function Call (Invocation)
336(1)
Function Declarations and Definitions
337(3)
Local Variables
340(1)
The Return Statement
341(2)
Matters of Style: Naming Void Functions
343(1)
Header Files
343(1)
Parameters
344(10)
Value Parameters
345(1)
Reference Parameters
346(4)
An Analogy
350(1)
Matching Arguments with Parameters
350(3)
Theoretical Foundations: Argument-Passing Mechanisms
353(1)
Designing Functions
354(9)
Writing Assertions as Program Comments
356(2)
Matters of Style: Function Preconditions and Postconditions
358(1)
Documenting the Direction of Data Flow
358(2)
Matters of Style: Formatting Function Headings
360(1)
Software Engineering Tip: Conceptual Versus Physical Hiding of a Function Implementation
361(2)
Problem-Solving Case Study: Comparison of Furniture-Store Sales
363(9)
Testing and Debugging
372(4)
The assert Library Function
374(2)
Testing and Debugging Hints
376(1)
Summary
376(15)
Quick Check
377(1)
Exam Preparation Exercises
378(5)
Programming Warm-up Exercises
383(2)
Programming Problems
385(5)
Case Study Follow-Up
390(1)
Scope, Lifetime, and More on Functions
391(70)
Scope of Identifiers
392(11)
Scope Rules
395(4)
Variable Declarations and Definitions
399(1)
Namespaces
400(3)
Lifetime of a Variable
403(2)
Initializations in Declarations
404(1)
Interface Design
405(6)
Side Effects
406(3)
Global Constants
409(1)
May We Introduce: Ada Lovelace
409(2)
Value-Returning Functions
411(12)
Boolean Functions
416(3)
Matters of Style: Naming Value-Returning Functions
419(1)
Interface Design and Side Effects
420(1)
When to Use Value-Returning Functions
421(1)
Background Information: Ignoring a Function Value
421(2)
Problem-Solving Case Study: Reformat Dates
423(12)
Software Engineering Tip: Control Abstraction, Functional Cohesion, and Communication Complexity
434(1)
Problem-Solving Case Study: Starship Weight and Balance
435(11)
Testing and Debugging
446(4)
Stubs and Drivers
447(2)
Testing and Debugging Hints
449(1)
Summary
450(11)
Quick Check
451(1)
Exam Preparation Exercises
452(3)
Programming Warm-up Exercises
455(2)
Programming Problems
457(2)
Case Study Follow-Up
459(2)
Additional Control Structures
461(32)
The Switch Statement
462(6)
May We Introduce: Admiral Grace Murray Hopper
466(2)
The Do-While Statement
468(3)
The For Statement
471(3)
The Break and Continue Statements
474(3)
Guidelines for Choosing a Looping Statement
477(1)
Problem-Solving Case Study: Monthly Rainfall Averages
478(6)
Testing and Debugging
484(1)
Testing and Debugging Hints
484(1)
Summary
485(8)
Quick Check
485(1)
Exam Preparation Exercises
486(2)
Programming Warm-up Exercises
488(1)
Programming Problems
489(2)
Case Study Follow-Up
491(2)
Simple Data Types: Built-In and User-Defined
493(84)
Built-In Simple Types
494(8)
Integral Types
496(4)
Floating-Point Types
500(2)
Additional C++ Operators
502(9)
Assignment Operators and Assignment Expressions
503(2)
Increment and Decrement Operators
505(1)
Bitwise Operators
505(1)
The Cast Operation
506(1)
The sizeof Operator
507(1)
The ?: Operator
507(1)
Operator Precedence
508(3)
Working with Character Data
511(9)
Character Sets
511(2)
C++ char Constants
513(2)
Programming Techniques
515(5)
More on Floating-Point Numbers
520(12)
Representation of Floating-Point Numbers
520(3)
Arithmetic with Floating-Point Numbers
523(1)
Implementation of Floating-Point Numbers in the Computer
524(6)
Background Information Practical Implications of Limited Precision
530(1)
Software Engineering Tip Choosing a Numeric Data Type
531(1)
User-Defined Simple Types
532(11)
The Typedef Statement
532(1)
Enumeration Types
533(8)
Named and Anonymous Data Types
541(1)
User-Written Header Files
542(1)
More on Type Coercion
543(4)
Type Coercion in Arithmetic and Relational Expressions
544(1)
Type Coercion in Assignments, Argument Passing, and Return of a Function Value
545(2)
Problem-Solving Case Study: Finding the Area Under a Curve
547(8)
Problem-Solving Case Study: Rock, Paper, Scissors
555(10)
Testing and Debugging
565(3)
Floating-Point Data
565(1)
Coping with Input Errors
566(1)
Testing and Debugging Hints
567(1)
Summary
568(9)
Quick Check
569(1)
Exam Preparation Exercises
570(2)
Programming Warm-up Exercises
572(1)
Programming Problems
573(1)
Case Study Follow-Up
574(3)
Structured Types, Data Abstraction, and Classes
577(86)
Simple Versus Structured Data Types
578(1)
Records (C++ Structs)
579(10)
Accessing Individual Components
582(1)
Aggregate Operations on Structs
583(2)
More About Struct Declarations
585(2)
Hierarchical Records
587(2)
Unions
589(1)
Data Abstraction
590(2)
Abstract Data Types
592(4)
Theoretical Foundations: Categories of Abstract Data Type Operations
595(1)
C++ Classes
596(10)
Matters of Style: Declaring Public and Private Class Members
599(1)
Classes, Class Objects, and Class Members
600(1)
Built-in Operations on Class Objects
601(2)
Class Scope
603(1)
Information Hiding
604(2)
Specification and Implementation Files
606(10)
The Specification File
606(2)
The Implementation File
608(5)
Compiling and Linking a Multifile Program
613(3)
Guaranteed Initialization with Class Constructors
616(5)
Invoking a Constructor
617(1)
Revised Specification and Implementation Files for TimeType
618(2)
Guidelines for Using Class Constructors
620(1)
Problem-Solving Case Study: Manipulating Dates
621(13)
Problem-Solving Case Study: Birthday Calls
634(10)
Testing and Debugging
644(5)
Testing and Debugging Hints
648(1)
Summary
649(14)
Quick Check
650(2)
Exam Preparation Exercises
652(4)
Programming Warm-up Exercises
656(2)
Programming Problems
658(3)
Case Study Follow-Up
661(2)
Arrays
663(80)
One-Dimensional Arrays
664(17)
Declaring Arrays
666(1)
Accessing Individual Components
667(3)
Out-of-Bounds Array Indexes
670(1)
Initializing Arrays in Declarations
671(1)
(Lack of) Aggregate Array Operations
671(2)
Examples of Declaring and Accessing Arrays
673(3)
Passing Arrays as Arguments
676(3)
Background Information: C, C++, and Arrays as Arguments
679(1)
Assertions About Arrays
679(1)
Using Typedef with Arrays
680(1)
Arrays of Records and Class Objects
681(3)
Arrays of Records
681(2)
Arrays of Class Objects
683(1)
Special Kinds of Array Processing
684(1)
Subarray Processing
684(1)
Indexes with Semantic Content
684(1)
Two-Dimensional Arrays
685(4)
Processing Two-Dimensional Arrays
689(6)
Sum the Rows
690(1)
Sum the Columns
691(1)
Initialize the Array
692(2)
Print the Array
694(1)
Passing Two-Dimensional Arrays as Arguments
695(3)
Another Way of Defining Two-Dimensional Arrays
698(2)
Multidimensional Arrays
700(3)
Problem-Solving Case Study: Comparison of Two Lists
703(7)
Problem-Solving Case Study: City Council Election
710(11)
Testing and Debugging
721(5)
One-Dimensional Arrays
721(1)
Complex Structures
722(1)
Multidimensional Arrays
723(2)
Testing and Debugging Hints
725(1)
Summary
726(17)
Quick Check
726(3)
Exam Preparation Exercises
729(5)
Programming Warm-up Exercises
734(3)
Programming Problems
737(4)
Case Study Follow-Up
741(2)
Array-Based Lists
743(58)
The List as an Abstract Data Type
744(4)
Unsorted Lists
748(10)
Basic Operations
748(3)
Insertion and Deletion
751(1)
Sequential Search
752(3)
Sorting
755(3)
Sorted Lists
758(15)
Basic Operations
761(1)
Insertion
761(3)
Sequential Search
764(1)
Binary Search
765(5)
Deletion
770(2)
Theoretical Foundations: Complexity of Searching and Sorting
772(1)
Understanding Character Strings
773(10)
Initializing C Strings
776(1)
C String Input and Output
777(4)
C String Library Routines
781(2)
String Class or C Strings?
783(1)
Problem-Solving Case Study: Exam Attendance
783(9)
Testing and Debugging
792(1)
Testing and Debugging Hints
792(1)
Summary
793(8)
Quick Check
793(2)
Exam Preparation Exercises
795(2)
Programming Warm-up Exercises
797(1)
Programming Problems
798(1)
Case Study Follow-Up
799(2)
Object-Oriented Software Development
801(66)
Object-Oriented Programming
802(2)
Objects
804(1)
Inheritance
805(12)
Deriving One Class from Another
807(3)
Software Engineering Tip: Inheritance and Accessibility
810(1)
Specification of the ExtTime Class
811(1)
Implementation of the ExtTime Class
812(4)
Avoiding Multiple Inclusion of Header Files
816(1)
Composition
817(5)
Design of a TimeCard Class
818(2)
Implementation of the TimeCard Class
820(2)
Dynamic Binding and Virtual Functions
822(5)
The Slicing Problem
823(2)
Virtual Functions
825(2)
Object-Oriented Design
827(4)
Identify the Objects and Operations
828(1)
Determine the Relationships Among Objects
829(1)
Design the Driver
830(1)
Software Engineering Tip: The Iterative Nature of Object-Oriented Design
830(1)
Implementing the Design
831(1)
Problem-Solving Case Study: Time Card Lookup
832(22)
Testing and Debugging
854(1)
Testing and Debugging Hints
854(1)
Summary
855(12)
Quick Check
856(2)
Exam Preparation Exercises
858(4)
Programming Warm-up Exercises
862(1)
Programming Problems
863(1)
Case Study Follow-Up
864(3)
Pointers, Dynamic Data, and Reference Types
867(76)
Pointers
868(11)
Pointer Variables
869(6)
Pointer Expressions
875(4)
Dynamic Data
879(5)
Reference Types
884(6)
Classes and Dynamic Data
890(11)
Class Destructors
894(1)
Shallow Versus Deep Copying
895(2)
Class Copy-Constructors
897(4)
Problem-Solving Case Study: Personnel Records
901(16)
Problem-Solving Case Study: Dynamic Arrays
917(11)
Testing and Debugging
928(3)
Testing and Debugging Hints
930(1)
Summary
931(12)
Quick Check
932(2)
Exam Preparation Exercises
934(3)
Programming Warm-up Exercises
937(2)
Programming Problems
939(1)
Case Study Follow-Up
940(3)
Linked Structures
943(70)
Sequential Versus Linked Structures
944(2)
Array Representation of a Linked List
946(2)
Dynamic Data Representation of a Linked List
948(29)
Algorithms on Dynamic Linked Lists
956(19)
Pointer Expressions
975(1)
Classes and Dynamic Linked Lists
976(1)
Choice of Data Representation
977(2)
Problem-Solving Case Study: Simulated Playing Cards
979(7)
Problem-Solving Case Study: Solitaire Simulation
986(20)
Testing and Debugging
1006(1)
Testing and Debugging Hints
1006(1)
Summary
1006(7)
Quick Check
1007(1)
Exam Preparation Exercises
1008(2)
Programming Warm-up Exercises
1010(1)
Programming Problems
1011(1)
Case Study Follow-Up
1012(1)
Recursion
1013
What Is Recursion?
1014(4)
Recursive Algorithms with Simple Variables
1018(3)
Towers of Hanoi
1021(5)
Recursive Algorithms with Structured Variables
1026(3)
Recursion Using Pointer Variables
1029(7)
Printing a Dynamic Linked List in Reverse Order
1029(3)
Copying a Dynamic Linked List
1032(4)
Recursion or Iteration?
1036(1)
Problem-Solving Case Study: Converting Decimal Integers to Binary Integers
1037(3)
Problem-Solving Case Study Minimum Value in an Integer Array
1040(3)
Testing and Debugging
1043(1)
Testing and Debugging Hints
1043(1)
Summary
1043
Quick Check
1044(1)
Exam Preparation Exercises
1044(2)
Programming Warm-up Exercises
1046(2)
Programming Problems
1048(1)
Case Study Follow-Up
1049
Appendix A Reserved Words 1(1)
Appendix B Operator Precedence 1(2)
Appendix C A Selection of Standard Library Routines 3(9)
Appendix D Using This Book with a Prestandard Version of C++ 12(4)
Appendix E Character Sets 16(2)
Appendix F Program Style, Formatting, and Documentation 18(9)
Glossary 27(10)
Answers to Selected Exercises 37(30)
Index 67

An electronic version of this book is available through VitalSource.

This book is viewable on PC, Mac, iPhone, iPad, iPod Touch, and most smartphones.

By purchasing, you will be able to view this book online, as well as download it, for the chosen number of days.

Digital License

You are licensing a digital product for a set duration. Durations are set forth in the product description, with "Lifetime" typically meaning five (5) years of online access and permanent download to a supported device. All licenses are non-transferable.

More details can be found here.

A downloadable version of this book is available through the eCampus Reader or compatible Adobe readers.

Applications are available on iOS, Android, PC, Mac, and Windows Mobile platforms.

Please view the compatibility matrix prior to purchase.