CART

(0) items

Problem Solving, Abstraction, and Design Using C++,9780321450050
This item qualifies for
FREE SHIPPING!

FREE SHIPPING OVER $59!

Your order must be $59 or more, you must select US Postal Service Shipping as your shipping preference, and the "Group my items into as few shipments as possible" option when you place your order.

Bulk sales, PO's, Marketplace Items, eBooks, Apparel, and DVDs not included.

Problem Solving, Abstraction, and Design Using C++

by ;
Edition:
5th
ISBN13:

9780321450050

ISBN10:
0321450051
Format:
Paperback
Pub. Date:
1/1/2007
Publisher(s):
Addison Wesley
List Price: $119.00

Buy Used Textbook

(Recommended)
Usually Ships in 2-3 Business Days
U9780321450050
$83.30

Buy New Textbook

Currently Available, Usually Ships in 24-48 Hours
N9780321450050
$116.03

Rent Textbook

We're Sorry
Sold Out

eTextbook

We're Sorry
Not Available

More New and Used
from Private Sellers
Starting at $8.99
See Prices

Questions About This Book?

What version or edition is this?
This is the 5th edition with a publication date of 1/1/2007.
What is included with this book?
  • The New copy of this book will include any supplemental materials advertised. Please check the title of the book to determine if it should include any CDs, lab manuals, study guides, etc.
  • The Used copy of this book is not guaranteed to inclue any supplemental materials. Typically, only the book itself is included.

Related Products


  • Problem Solving, Abstraction, & Design Using C++: The Visual C++ Manual
    Problem Solving, Abstraction, & Design Using C++: The Visual C++ Manual
  • Problem Solving, Abstraction, and Design Using C++
    Problem Solving, Abstraction, and Design Using C++
  • Problem Solving, Abstraction, and Design Using C++
    Problem Solving, Abstraction, and Design Using C++
  • Problem Solving, Abstraction, and Design Using C++
    Problem Solving, Abstraction, and Design Using C++




Summary

Problem Solving, Abstraction, and Design Using C++ presents and reinforces basic principles of software engineering design and object-oriented programming concepts while introducing the C++ programming language. The hallmark feature of this book is the Software Development Method that is introduced in the first chapter and carried throughout in the case studies presented.

Table of Contents

Introduction to Computers, Problem Solving, and Programming
1(38)
Overview of Computers
2(2)
Early Computers
2(1)
Categories of Computers
3(1)
Sharing Computer Resources
3(1)
Computer Hardware
4(8)
Memory
6(1)
Main Memory
7(2)
Central Processing Unit
9(1)
Input/Output Devices
10(1)
Computer Networks
11(1)
The World Wide Web
11(1)
Computer Software
12(7)
Operating System
13(1)
Application Software
14(1)
Programming Languages
15(1)
Object-Oriented Programming
16(3)
Processing a High-Level Language Program
19(4)
Executing a Program
21(2)
The Software Development Method
23(3)
Caution: Failure Is Part of the Process
25(1)
Applying the Software Development Method
26(3)
Case Study: Converting Miles to Kilometers
27(2)
Professional Ethics for Computer Programmers
29(10)
Privacy and Misuse of Data
29(1)
Computer Hacking
30(1)
Plagiarism and Software Piracy
30(1)
Misuse of a Computer Resource
31(1)
Chapter Review
32(1)
Quick-Check Exercises
33(1)
Answers to Quick-Check Exercises
34(1)
Review Questions
34(2)
Interview with Bjarne Stroustrup
36(3)
Overview of C++
39(64)
C++ Language Elements
40(5)
Comments
40(1)
Compiler Directive #include
41(1)
Namespace std
42(1)
Function main
42(1)
Declaration Statements
43(1)
Executable Statements
44(1)
Reserved Words and Identifiers
45(4)
Reserved Words
45(1)
Identifiers
46(1)
Uppercase and Lowercase Letters
47(2)
Data Types and Declarations
49(8)
Data Types
49(3)
String Class
52(1)
Purpose of Data Types
53(1)
Declarations
53(1)
Constant Declarations
54(3)
Executable Statements
57(9)
Programs in Memory
57(1)
Assignment Statements
57(3)
Input/Output Operations
60(1)
Input Statements
60(2)
Program Output
62(2)
The return Statement
64(2)
General Form of a C++ Program
66(3)
Comments in Programs
67(2)
Arithmetic Expressions
69(15)
Operators / and %
70(2)
Data Type of a Mixed-Type Expression
72(1)
Mixed-Type Assignment Statement
72(1)
Expressions with Multiple Operators
73(4)
Writing Mathematical Formulas in C++
77(2)
Case Study: Finding the Value of a Coin Collection
79(5)
Interactive Mode, Batch Mode, and Data Files
84(3)
Input Redirection
84(1)
Output Redirection
85(2)
Common Programming Errors
87(16)
Syntax Errors
87(2)
Run-Time Errors
89(1)
Undetected Errors
89(2)
Logic Errors
91(1)
Chapter Review
91(2)
Quick-Check Exercises
93(1)
Answers to Quick-Check Exercises
94(1)
Review Questions
95(1)
Programming Projects
96(4)
Interview with Josee Lajoie
100(3)
Top-Down Design with Functions and Classes
103(62)
Building Programs from Existing Information
104(8)
Case Study: Finding the Area and Circumference of a Circle
105(2)
Case Study: Computing the Weight of a Batch of Flat Washers
107(5)
Library Functions
112(6)
C++ Library Functions
113(4)
A Look Ahead
117(1)
Top-Down Design and Structure Charts
118(2)
Case Study: Drawing Simple Figures
118(2)
Functions without Arguments
120(10)
Function Prototypes
122(1)
Function Definitions
122(2)
Placement of Functions in a Program
124(1)
Order of Execution of Functions
124(2)
Advantages of Using Function Subprograms
126(4)
Functions with Input Arguments
130(10)
Void Functions with Input Arguments
132(1)
Functions with Input Arguments and a Single Result
132(5)
Functions with Multiple Arguments
137(1)
Argument/Parameter List Correspondence
138(1)
The Function Data Area
139(1)
Testing Functions Using Drivers
139(1)
Scope of Names
140(3)
Extending C++ through Classes: Using Class string
143(7)
The string Class
143(2)
Declaring string Objects
145(1)
Reading and Displaying string Objects
145(1)
String Assignment and Concatenation
146(1)
Operator Overloading
146(1)
Dot Notation: Calling Functions length and at
146(1)
Member Functions for Word-Processing Operations
147(1)
Assigning a Substring to a string Object
148(2)
Common Programming Errors
150(15)
Separately Testing Function Subprograms
153(1)
Chapter Review
153(2)
Quick-Check Exercises
155(1)
Answers to Quick-Check Exercises
156(1)
Review Questions
157(1)
Programming Projects
158(4)
Interview with Mark Hall
162(3)
Selection Structures: if and switch Statements
165(60)
Control Structures
166(1)
Logical Expressions
166(11)
Logical Expressions Using Relational and Equality Operators
167(1)
Logical Expressions Using Logical Operators
168(2)
Operator Precedence
170(2)
Writing Conditions in C++
172(2)
Comparing Characters and Strings
174(1)
Boolean Assignment
175(1)
Writing bool Values
176(1)
Using Integers to Represent Logical Values
176(1)
Introduction to the if Control Statement
177(6)
if Statement with Two Alternatives
178(1)
if Statement with Dependent Statement
179(1)
if Statement Conditions with Characters and Strings
179(2)
Format of the if Statement
181(2)
if Statements with Compound Alternatives
183(4)
Tracing an if Statement
184(3)
Decision Steps in Algorithms
187(10)
Case Study: Payroll Problem with Functions
187(8)
A Reminder About Identifier Scope
195(1)
Adding Data Flow Information to Structure Charts
195(1)
Commentary---The Software Development Method
196(1)
Checking the Correctness of an Algorithm
197(2)
Nested if Statements and Multiple-Alternative Decisions
199(8)
Comparision of Nested if Statements and a Sequence of if Statements
200(1)
Writing a Nested if as a Multiple-Alternative Decision
200(2)
Order of Conditions
202(3)
Short-Circuit Evaluation of Logical Expressions
205(2)
The switch Control Statement
207(5)
Proper Use of break
210(1)
Comparison of Nested if Statements and the switch Statement
210(1)
Using a switch Statement to Select Alternative Functions
210(2)
Common Programming Errors
212(13)
Chapter Review
213(1)
Quick-Check Exercises
214(4)
Answers to Quick-Check Exercises
218(1)
Review Questions
219(1)
Programming Projects
220(5)
Repetition and Loop Statements
225(68)
Counting Loops and the while Statement
226(5)
The while Statement
227(1)
Syntax of the while Statement
228(3)
Accumulating a Sum or Product in a Loop
231(6)
Multiplying a List of Numbers
234(1)
Compound Assignment Operators
234(3)
The for Statement
237(8)
Increment and Decrement Operators
239(2)
Increments and Decrements Other than One
241(1)
Displaying a Table of Values
242(3)
Conditional Loops
245(7)
A Loop with a Decreasing Loop Control Variable
246(1)
Case Study: Monitoring Oil Supply
246(4)
More General Conditional Loops
250(2)
Loop Design and Loop Patterns
252(7)
Sentinel-Controlled Loops
253(3)
Calculating an Average
256(1)
Flag-Controlled Loops
257(2)
The do--while Statement
259(6)
Review of while, for, and do-while Loops
265(2)
Nested Loops
267(5)
Debugging and Testing Programs
272(3)
Using a Debugger
272(1)
Debugging without a Debugger
273(1)
Off-by-One Errors
274(3)
Testing
277
Common Programming Errors
275(18)
Chapter Review
278(1)
Quick-Check Exercises
279(3)
Answers to Quick-Check Exercises
282(1)
Review Questions
283(1)
Programming Projects
284(6)
Interview with Mike Weisert
290(3)
Modular Programming
293(54)
Value and Reference Parameters
294(10)
Call-by-Value and Call-by-Reference Parameters
296(2)
void Functions Can Return Results
298(1)
When to Use a Reference or a Value Parameter
298(1)
Comparison of Value and Reference Parameters
299(1)
Protection Afforded by Value Parameters
299(1)
Argument/Parameter List Correspondence Revisited
300(4)
Functions with Output and Input Parameters
304(7)
Stepwise Design with Functions
311(10)
Case Study: General Sum and Average Problem
311(8)
Multiple Declarations of Identifiers in a Program
319(2)
Using Objects with Functions
321(2)
Debugging and Testing a Program System
323(5)
Top-Down Testing and Stubs
323(1)
Bottom-Up Testing and Drivers
324(1)
Debugging Tips for Program Systems
325(1)
Identifier Scope and Watch Window Variables
326(1)
Black-Box versus White-Box Testing
326(2)
Recursive Functions (Optional)
328(4)
Common Programing Errors
332(15)
Chapter Review
333(1)
Quick-Check Exercises
333(2)
Answers to Quick-Check Exercises
335(1)
Review Questions
336(1)
Programming Projects
337(7)
Intervew with Robert Sebesta
344(3)
Simple Data Types
347(40)
Constants Revisited
348(1)
The #define Compiler Directive
348(1)
Internal Representations of Numeric Data Types
349(7)
Fixed-Point and Floating-Point Data Types
349(1)
Integer Types
350(1)
Floating-Point Types
351(1)
Types of Numeric Literals
351(1)
Value Ranges for Integer and Floating-Point Types
351(1)
Numerical Inaccuracies
351(2)
Mixing Types: Promotions
353(1)
Type Conversions
353(1)
Type Casting
354(2)
Character Data and Functions
356(5)
Some Useful Character Functions
357(4)
Type bool Data and Logical Expressions
361(4)
Complementing Logical Expressions
361(2)
Type bool Functions
363(1)
Input and Output of Type bool Data
363(2)
Enumeration Types
365(9)
Characters as Enumerator Values
367(1)
Comparisons Involving Enumeration Types
368(1)
Distinctions among Integral Types
368(1)
Reading and Writing Enumeration Type Values
368(3)
Placement of Enumeration Type Declarations
371(1)
Enumeration Types as Cast Operators
371(3)
Common Programming Errors
374(13)
Chapter Review
376(1)
Quick-Check Exercises
377(1)
Answers to Quick-Check Exercises
378(1)
Review Questions
379(1)
Programming Projects
380(4)
Interview with Thomas Drake
384(3)
Streams and Files
387(44)
The Standard Input/Output Streams
387(9)
Reading One Character at a Time
392(4)
External Files
396(9)
Interactive versus Batch Processing
396(1)
Directory Names for External Files
397(1)
Attaching Streams to External Files
397(4)
Function copyLine
401(1)
More on the Newline Character
401(2)
Using getline with a File Stream
403(2)
Using External Files for Communication between Programs
405(6)
Case Study: Preparing a Payroll File
405(6)
More on Reading String Data
411(3)
Using ignore to Advance Past the Newline Character
411(3)
Input/Output Manipulators
414(2)
Common Programming Errors
416(15)
Chapter Review
418(2)
Quick-Check Exercises
420(1)
Answers to Quick-Check Exercises
420(1)
Review Questions
421(1)
Programming Projects
422(6)
Interview with Anita Borg
428(3)
Data Structures: Arrays and Structs
431(58)
The Array Data Type
432(7)
Array Declaration
432(3)
Array Initialization
435(1)
Array Subscripts
436(3)
Sequential Access to Array Elements
439(6)
Strings and Arrays of Characters
442(3)
Array Arguments
445(6)
Array Elements as Arguments
445
Passing an Array Argument
443(8)
Reading Part of an Array
451(3)
Searching and Sorting Arrays
454(7)
Finding the Smallest Value in an Array
454(2)
Array Search
456(1)
Sorting an Array in Ascending Order
457(4)
Analyzing Algorithms: Big-O Notation
461(3)
Analysis of a Search Algorithm
461(1)
Analysis of a Sort Algorithm
462(2)
The Struct Data Type
464(4)
Declaring a Struct Type and Struct Variables
464(2)
Accessing Members of a Struct
466(2)
Structs as Operands and Arguments
468(4)
Struct Copy or Assignment
468(1)
Passing a Struct as an Argument
468(2)
Reading a Struct
470(1)
Efficiency of Reference Arguments
471(1)
Strings as Arrays of Characters (Optional)
472(4)
Declaring and Initializing an Array of Characters
472(4)
Common Programming Errors
476(13)
Chapter Review
477(1)
Quick-Check Exercises
478(1)
Answers to Quick-Check Exercises
479(1)
Review Questions
480(2)
Programming Projects
482(7)
User-Defined Classes
489(64)
Class Definition and Use
490(8)
The counter Class
490(2)
Class Definition for the counter Class
492(2)
Compiler Directives in File counter.h
494(1)
Using the counter Class
495(1)
Compiler Directives in File CounterTest.cpp
496(2)
Class Implementation
498(4)
Constructors
500(1)
Accessor and Modifier Functions
500(1)
Compiler Directives in File counter. cpp
501(1)
Summary of Rules for Use of Classes and Objects
502(5)
Objects as Class Instances
502(1)
Public versus Private Access
502(1)
Syntax for Class and Member Function Definitions
503(2)
Comparing Structs and Classes
505(1)
Project Files and Separate Compilation
505(1)
Combining Arrays, Structs, and Classes
506(1)
Function Overloading and Polymorphism
506(1)
Classes as Operands and Arguments
507(2)
A Fraction Class
509(8)
Design of fraction Class
509(2)
Using Class fraction
511(2)
Implementation File for Class fraction
513(4)
A Circle Class
517(7)
Design of circle Class
517(3)
Using Class circle
520(1)
Implementation File for Class circle
521(3)
A Simple String Class
524(7)
Design of Class simpleString
524(1)
Definition of Class simpleString
524(2)
Testing Member Functions of Class simpleString
526(1)
Implementation File for Class simpleString
527(4)
A Savings Account Class
531(8)
Case Study: Using the Savings Account Class
531(8)
Common Programming Errors
539(14)
Chapter Review
541(1)
Quick-Check Exercises
541(2)
Answers to Quick-Check Exercises
543(1)
Review Questions
544(1)
Programming Projects
545(5)
Interview with Timothy Budd
550(3)
Data Abstraction and Object-Oriented Design
553(72)
Multidimensional Arrays
554(6)
Declaring Two-Dimensional Arrays
554(2)
Initializing Two-Dimensional Arrays
556(1)
Nested Loops for Processing Two-Dimensional Arrays
556(1)
Two-Dimensional Arrays as Function Arguments
557(1)
Arrays with Several Dimensions
558(2)
Array of Structs
560(4)
Template Classes
564(7)
Definition of a Template Class
564(3)
Implementation of a Template Class
567(3)
Compiler Instructions to Support Separate Compilation
570(1)
The Indexed List Abstract Data Type
571(7)
Need for an Indexed List Class
571(1)
Analysis and Design of an Indexed List Class
571(4)
Using the index List Class
575(3)
Implementing the Indexed List Class
578(1)
Illustrating Object-Oriented Design
578(16)
Case Study: A Telephone Directory Program
578(16)
Operator Overloading and Friends
594(6)
Operator Overloading
594(1)
Friends
595(2)
Implementing the Directory Entry Class
597(3)
The vector Class
600(9)
Vector Functions
602(1)
Accessing a Vector through an Iterator
603(1)
Standard Algorithms
604(1)
Using vector and algorithm Classes in the Telephone Directory Program
605(4)
Common Programming Errors
609(16)
Chapter Review
612(1)
Quick-Check Exercises
613(1)
Answers to Quick-Check Exercises
614(1)
Review Questions
615(1)
Programming Projects
616(6)
Interview with John Lakos
622(3)
Recursion
625(40)
The Nature of Recursion
626(3)
Properties of Recursive Problems and Solutions
627(2)
Tracing Recursive Functions
629(7)
Displaying Characters in Reverse Order
630(3)
Stack for Function Calls
633(2)
Implementation of Argument Stacks in C++
635(1)
Recursive Mathematical Functions
636(6)
Recursive Functions with Array Arguments
642(7)
Case Study: Binary Search
644(5)
Problem Solving with Recursion
649(6)
Case Study: The Towers of Hanoi
649(6)
Comparison of Iteration and Recursive Functions
655(1)
Common Programming Errors
655(10)
Chapter Review
657(1)
Quick-Check Exercises
657(1)
Answers to Quick-Check Exercises
658(1)
Review Questions
658(1)
Programming Projects
659(3)
Interview with Marshall Cline
662(3)
Pointers and Dynamic Data Structures
665(1)
Pointers and the new Operator
666(5)
Accessing Data with Pointers
667(1)
Pointer Operations
668(1)
Pointers to Structs
668(3)
Manipulating the Heap
671(3)
Effect of the new Operator on the Heap
672(1)
Returning Cells to the Heap
673(1)
Linked Lists and the list Class
674(11)
Declaring Nodes
674(1)
Connecting Nodes
675(1)
Inserting a Node in a List
676(1)
Insertion at the Head of a List
677(1)
Insertion at the End of a List
678(1)
Deleting a Node
679(1)
Traversing a List
679(2)
Circular Lists and Two-Way Lists (Optional)
681(4)
The Stack Abstract Data Type
685
The C++ stack Class
686(4)
Implementing a stack Template Class
690(2)
Implementing the Stack Operators
692(2)
Testing the Stack ADT
694
The Queue Abstract Data Type
679(23)
The C++ stack Class
696
Implementing a Queue ADT
680(22)
Binary Trees
702(7)
Binary Search Tree
703(1)
Searching a Binary Search Tree
704(1)
Building a Binary Search Tree
704(3)
Displaying a Binary Search Tree
707(2)
Binary Search Tree Abstract Data Type
709(8)
Design of Binary Tree Class
709(3)
Implementation of Binary Tree Class
712(5)
Efficiency of a Binary Search Tree
717(2)
Common Programming Errors
719
Syntax Errors
719(1)
Run-Time Errors
719(1)
Chapter Review
720(1)
Quick-Check Exercises
721(2)
Answers to Quick-Check Exercises
723(1)
Review Questions
723(2)
Programming Projects
725
Multiprocessing Using Processes and Threads
665(122)
Multitasking
732(5)
Linear versus Parallel Programming
732(1)
Multitasking as Time-Sharing
733(1)
Preemptive Multitasking
734(1)
Time Slices and Parallelism
735(1)
Concurrent Programming
736(1)
Processes
737(8)
Creating a Process
738(2)
Waiting for a Process
740(2)
Executing Another Program from a Process
742(3)
Interprocess Communications and Pipes
745(8)
Pipes
745(1)
Using Pipes
746(2)
Interprocess Communications Using Standard Input
748(1)
Illustrating Communication between a Parent and a Child Process
749(4)
Threads
753(26)
Creating a Thread
754(3)
Thread Synchronization
757(1)
Mutual Exclusion Locking
758(3)
Deadlocks
761(4)
Case Study: Threads Illustrated
765(14)
Common Programming Errors
779(8)
Chapter Review
780(1)
Review of C Constructs
781(1)
Quick-Check Exercises
782(1)
Answers to Quick-Check Exercises
783(1)
Review Questions
784(1)
Programming Projects
784(3)
Appendix A ASCH Character Set
787(1)
Appendix B Reserved Words and Special Characters
788
Appendix C Selected C++ Library Facilities
779(17)
Appendix D Operators
796(1)
Appendix E A Brief Introduction to Inheritance and Polymorphism
797(20)
Subclassing for Specialization
797(4)
Subclassing for Specification
801(13)
Case Study: Areas and Perimeters of Different Figures
802(12)
Commentary
814(1)
Polymorphism
815(2)
Answers to Odd-Numbered Questions 817(42)
Index 859


Please wait while the item is added to your cart...