Our Privacy Policy has changed. By using this site, you agree to the Privacy Policy.

C++ How to Program Covers ANSI/ISO

ISBN-10: 0130895717
ISBN-13: 9780130895714
Edition: 3rd 2001 (Student Manual, Study Guide, etc.)
List price: $78.67 Buy it from $1.75
30 day, 100% satisfaction guarantee

If an item you ordered from TextbookRush does not meet your expectations due to an error on our part, simply fill out a return request and then return it by mail within 30 days of ordering it for a full refund of item cost.

Learn more about our returns policy

Description: For Computer Science 1 and other courses covering programming in C++. Also appropriate as a supplement for upper-level courses where the instructor uses a book as a reference to the C++ language. This best-selling comprehensive text is aimed at  More...

Used Starting from $1.75
what's this?
Rush Rewards U
Members Receive:
You have reached 400 XP and carrot coins. That is the daily max!
You could win $10,000

Get an entry for every item you buy, rent, or sell.

Study Briefs

Limited time offer: Get the first one free! (?)

All the information you need in one place! Each Study Brief is a summary of one specific subject; facts, figures, and explanations to help you learn faster.

Add to cart
Study Briefs
SQL Online content $4.95 $1.99
Add to cart
Study Briefs
MS Excel® 2010 Online content $4.95 $1.99
Add to cart
Study Briefs
MS Word® 2010 Online content $4.95 $1.99
Add to cart
Study Briefs
MS PowerPoint® 2010 Online content $4.95 $1.99

Customers also bought


Book details

List price: $78.67
Edition: 3rd
Copyright year: 2001
Publisher: Prentice Hall PTR
Publication date: 8/3/2000
Binding: Paperback
Pages: 1168
Size: 7.00" wide x 9.00" long x 1.50" tall
Weight: 3.784
Language: English

For Computer Science 1 and other courses covering programming in C++. Also appropriate as a supplement for upper-level courses where the instructor uses a book as a reference to the C++ language. This best-selling comprehensive text is aimed at readers with little or no programming experience. It teaches programming by emphasizing achieving program clarity through structured and object-oriented programming, software reuse and component-oriented software construction.

Introduction to Computers and C++ Programming
What is a Computer?
Computer Organization
Evolution of Operating Systems
Personal Computing, Distributed Computing and Client/Server Computing
Machine Languages, Assembly Languages, and High-level Languages
History of C and C++
C++ Standard Library
Java and Java How to Program
Other High-level Languages
Structured Programming
The Key Software Trend: Object Technology
Basics of a Typical C++ Environment
Hardware Trends
History of the Internet
History of the World Wide Web
General Notes About C++ and This Book
Introduction to C++ Programming
A Simple Program: Printing a Line of Text
Another Simple Program: Adding Two Integers
Memory Concepts
Decision Making: Equality and Relational Operators
Thinking About Objects: Introduction to Object Technology and the Unified Modeling Language
Control Structures
Control Structures
The if Selection Structure
The if/else Selection Structure
The while Repetition Structure
Formulating Algorithms: Case Study 1 (Counter-Controlled Repetition)
Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 2 (Sentinel-Controlled Repetition)
Formulating Algorithms with Top-Down, Stepwise Refinement: Case Study 3 (Nested Control Structures)
Assignment Operators
Increment and Decrement Operators
Essentials of Counter-Controlled Repetition
The for Repetition Structure
Examples Using the for Structure
The switch Multiple-Selection Structure
The do/while Repetition Structure
The break and continue Statements
Logical Operators
Confusing Equality (==) and Assignment (=) Operators
Structured-Programming Summary
[Optional Case Study] Thinking About Objects: Identifying the Classes in a Problem
Program Components in C++
Math Library Functions
Function Definitions
Function Prototypes
Header Files
Random Number Generation
Example: A Game of Chance and Introducing enum
Storage Classes
Scope Rules
Example Using Recursion: The Fibonacci Series
Recursion vs. Iteration
Functions with Empty Parameter Lists
Inline Functions
References and Reference Parameters
Default Arguments
Unary Scope Resolution Operator
Function Overloading
Function Templates
[Optional Case Study] Thinking About Objects: Identifying a Class's Attributes
Declaring Arrays
Examples Using Arrays
Passing Arrays to Functions
Sorting Arrays
Case Study: Computing Mean, Median and Mode Using Arrays
Searching Arrays: Linear Search and Binary Search
Multiple-Subscripted Arrays
[Optional Case Study] Thinking About Objects: Identifying the Operations of a Class
Pointers and Strings
Pointer Variable Declarations and Initialization
Pointer Operators
Calling Functions by Reference
Using the const Qualifier with Pointers
Bubble Sort Using Call-by-reference
Pointer Expressions and Pointer Arithmetic
The Relationship Between Pointers and Arrays
Arrays of Pointers
Case Study: A Card Shuffling and Dealing Simulation
Function Pointers
Introduction to Character and String Processing
Fundamentals of Characters and Strings
String Manipulation Functions of the String-handling Library
[Optional Case Study] Thinking About Objects: Collaborations Among Objects
Classes and Data Abstraction
Structure Definitions
Accessing Members of Structures
Implementing a User-Defined Type Time with a struct
Implementing a Time Abstract Data Type with a class
Class Scope and Accessing Class Members
Separating Interface from Implementation
Controlling Access to Members
Access Functions and Utility Functions
Initializing Class Objects: Constructors
Using Default Arguments with Constructors
Using Destructors
When Constructors and Destructors Are Called
Using Data Members and Member Functions
A Subtle Trap: Returning a Reference to a Private Data Member
Assignment by Default Memberwise Copy
Software Reusability
[Optional Case Study) Thinking About Objects: Starting to Program the Classes for the Elevator Simulator
Classes: Part II
const (Constant) Objects and const Member Functions
Composition: Objects as Members of Classes
friend Functions and friend Classes
Using the this Pointer
Dynamic Memory Allocation with Operators new and delete
static Class Members
Data Abstraction and Information Hiding
Example: Array Abstract Data Type
Example: String Abstract Data Type
Example: Queue Abstract Data Type
Container Classes and Iterators
Proxy Classes
[Optional Case Study] Thinking About Objects: Programming the Classes for the Elevator Simulator
Operator Overloading
Fundamentals of Operator Overloading
Restrictions on Operator Overloading
Operator Functions as Class Members vs. as friend Functions
Overloading Stream-Insertion and Stream-Extraction Operators
Overloading Unary Operators
Overloading Binary Operators
Case Study: An Array Class
Converting between Types
Case Study: A String Class
Overloading ++ and --
Case Study: A Date Class
Inheritance: Base Classes and Derived Classes
Protected Members
Casting Base-Class Pointers to Derived-Class Pointers
Using Member Functions
Overriding Base-Class Members in a Derived Class
public, protected and private Inheritance
Direct Base Classes and Indirect Base Classes
Using Constructors and Destructors in Derived Classes
Implicit Derived-Class Object to Base-Class Object Conversion
Software Engineering with Inheritance
Composition vs. Inheritance
"Uses A" and "Knows A" Relationships
Case Study: Point, Circle, Cylinder
Multiple Inheritance
[Optional Case Study] Thinking About Objects: Incorporating Inheritance into the Elevator Simulation
Virtual Functions and Polymorphism
Type Fields and switch Statements
virtual Functions
Abstract Base Classes and Concrete Classes
Case Study: A Payroll System Using Polymorphism
New Classes and Dynamic Binding
virtual Destructors
Case Study: Inheriting Interface and Implementation
Polymorphism, virtual Functions and Dynamic Binding "Under the Hood"
C++ Stream Input/Output
Iostream Library Header Files
Stream Input/Output Classes and Objects
Stream Output
Stream-Insertion Operator
Cascading Stream-Insertion/Extraction Operators
Output of char * Variables
Character Output with Member Function put; Cascading puts
Stream Input
Stream-Extraction Operator
get and getline Member Functions
istream Member Functions peek, putback and ignore
Type-Safe I/O
Unformatted I/O with read, gcount and write
Stream Manipulators
Integral Stream Base: dec, oct, hex and setbase
Floating-Point Precision (precision, setprecision)
Field Width (setw, width)
User-Defined Manipulators
Stream Format States
Format State Flags
Trailing Zeros and Decimal Points (ios::showpoint)
Justification (ios::left, ios::right, ios::internal)
Padding (fill, setfill)
Integral Stream Base (ios::dec, ios::oct, ios::hex, ios::showbase)
Floating-Point Numbers; Scientific Notation (ios::scientific, ios::fixed)
Uppercase/Lowercase Control (ios::uppercase)
Setting and Resetting the Format Flags (flags, setiosflags, resetiosflags)
Stream Error States
Tying an Output Stream to an Input Stream
Function Templates
Overloading Template Functions
Class Templates
Class Templates and Nontype Parameters
Templates and Inheritance
Templates and friends
Templates and static Members
Exception Handling
When Exception Handling Should Be Used
Other Error-Handling Techniques
Basics of C++ Exception Handling: try, throw, catch
A Simple Exception-Handling Example: Divide by Zero
Throwing an Exception
Catching an Exception
Rethrowing an Exception
Exception Specifications
Processing Unexpected Exceptions
Stack Unwinding
Constructors, Destructors and Exception Handling
Exceptions and Inheritance
Processing new Failures
Class auto_ptr and Dynamic Memory Allocation
Standard Library Exception Hierarchy
File Processing
The Data Hierarchy
Files and Streams
Creating a Sequential Access File
Reading Data from a Sequential Access File
Updating Sequential Access Files
Random-Access Files
Creating a Random-Access File
Writing Data Randomly to a Random-Access File
Reading Data Sequentially from a Random-Access File
Example: A Transaction Processing Program
Input/Output of Objects
Data Structures
Self-Referential Classes
Dynamic Memory Allocation
Linked Lists
Bits, Characters, Strings and Structures
Structure Definitions
Initializing Structures
Using Structures with Functions
Example: High-Performance Card-shuffling and Dealing Simulation
Bitwise Operators
Bit Fields
Character-handling Library
String Conversion Functions
Search Functions of the String-handling Library
Memory Functions of the String-handling Library
Another Function of the String-handling Library
The Preprocessor
The #include Preprocessor Directive
The #define Preprocessor Directive: Symbolic Constants
The #define Preprocessor Directive: Macros
Conditional Compilation
The #error and #pragma Preprocessor Directives
The # and ## Operators
Line Numbers
Predefined Symbolic Constants
C Legacy Code Topics
Redirecting Input/Output on UNIX and DOS Systems
Variable-Length Argument Lists
Using Command-Line Arguments
Notes on Compiling Multiple-Source-File Programs
Program Termination with exit and atexit
The volatile Type Qualifier
Suffixes for Integer and Floating-Point Constants
Signal Handling
Dynamic Memory Allocation with calloc and realloc
The Unconditional Branch: goto
Linkage Specifications
Class string and String Stream Processing
string Assignment and Concatenation
Comparing strings
Swapping strings
string Characteristics
Finding Characters in a string
Replacing Characters in a string
Inserting Characters into a string
Conversion to C-Style char * Strings
String Stream Processing
Standard Template Library (STL)
Introduction to the Standard Template Library (STL)
Introduction to Containers
Introduction to Iterators
Introduction to Algorithms
Sequence Containers
vector Sequence Container
list Sequence Container
deque Sequence Container
Associative Containers
multiset Associative Container
set Associative Container
multimap Associative Container
map Associative Container
Container Adapters
stack Adapter
queue Adapter
priority_queue Adapter
fill, fill_n, generate and generate_n
equal, mismatch and lexicographical_compare
remove, remove_if, remove_copy and remove_copy_if
replace, replace_if, replace_copy and replace_copy_if
Mathematical Algorithms
Basic Searching and Sorting Algorithms
swap, iter_swap and swap_ranges
copy_backward, merge, unique and reverse
inplace_merge, unique_copy and reverse_copy
Set Operations
lower_bound, upper_bound and equal_range
min and max
Algorithms Not Covered in This Chapter
Class bitset
Function Objects
Standard C++ Language Additions
bool Data Type
static_cast Operator
const_cast Operator
reinterpret_cast Operator
Run-Time Type Information (RTTI)
Operator Keywords
explicit Constructors
mutable Class Members
Pointers to Class Members (.* and -]*)
Multiple Inheritance and virtual Base Classes
Closing Remarks
Operator Precedence Chart
ASCII Character Set
Number Systems
Abbreviating Binary Numbers as Octal Numbers and Hexadecimal Numbers
Converting Octal Numbers and Hexadecimal Numbers to Binary Numbers
Converting from Binary, Octal, or Hexadecimal to Decimal
Converting from Decimal to Binary, Octal, or Hexadecimal
Negative Binary Numbers: Two's Complement Notation
C++ Internet and Web Resources
Visual C++
Development Tools
Standard Template Library

Free shipping on orders over $35*

*A minimum purchase of $35 is required. Shipping is provided via FedEx SmartPost® and FedEx Express Saver®. Average delivery time is 1 – 5 business days, but is not guaranteed in that timeframe. Also allow 1 - 2 days for processing. Free shipping is eligible only in the continental United States and excludes Hawaii, Alaska and Puerto Rico. FedEx service marks used by permission."Marketplace" orders are not eligible for free or discounted shipping.

Learn more about the TextbookRush Marketplace.