Big C++: Late Objects, Enhanced eText
by Cay S. Horstmann
3rd Edition
Publisher: Wiley
(0 reviews)
Book Details
| Print ISBN | 9781119402909 |
| eText ISBN | 9781119402978 |
| Publisher | Wiley |
| Publishing Year | 2018 |
| Edition | 3rd Edition |
| Language | English |
| Pages | 848 |
Big C++: Late Objects, Enhanced eText, 3rd Edition serves as a textbook for a two-semester introductory programming sequence. The text requires no previous programming background and only modest high school algebra, offering an approachable entry to fundamental programming techniques and design skills.
The volume organizes instruction into two main segments. The first half addresses foundational coding skills, while the second half introduces algorithms and common data structures tailored for beginning students. Practical applications extend to contemporary topics such as graphical user interfaces and XML programming.
To support active practice, the text presents explicit problem-solving strategies alongside interactive learning activities and media computation exercises involving images, sounds, and animations.
Table of Contents
Chapter 1: Introduction
- • 1.1 What is Programming?
- • 1.2 The Anatomy of a Computer
- • C&S Computers are Everywhere
- • 1.3 Machine Code and Programming Languages
- • C&S Standards Organizations
- • 1.4 Becoming Familiar with Your Programming Environment
- • PT 1 Backup Copies
- • 1.5 Analyzing Your First Program
- • CE 1 Omitting Semicolons
- • ST 1 Escape Sequences
- • 1.6 Errors
- • CE 2 Misspelling Words
- • 1.7 PROBLEM SOLVING Algorithm Design
- • The Algorithm Concept
- • An Algorithm for Solving an Investment Problem
- • Pseudocode
- • From Algorithms to Programs
- • HT 1 Describing an Algorithm with Pseudocode
- • WE 1 Writing an Algorithm for Tiling a Floor
Chapter 2: Fundamental Data Types
- • 2.1 Variables
- • Variable Definitions
- • Number Types
- • Variable Names
- • The Assignment Statement
- • Constants
- • Comments
- • CE 1 Using Undefined Variables
- • CE 2 Using Uninitialized Variables
- • PT 1 Choose Descriptive Variable Names
- • PT 2 Do Not Use Magic Numbers
- • ST 1 Numeric Types in C++
- • ST 2 Numeric Ranges and Precisions
- • ST 3 Defining Variables with auto
- • 2.2 Arithmetic
- • Arithmetic Operators
- • Increment and Decrement
- • Integer Division and Remainder
- • Converting Floating-Point Numbers to Integers
- • Powers and Roots
- • CE 3 Unintended Integer Division
- • CE 4 Unbalanced Parentheses
- • CE 5 Forgetting Header Files
- • CE 6 Roundoff Errors
- • PT 3 Spaces in Expressions
- • ST 4 Casts
- • ST 5 Combining Assignment and Arithmetic
- • C&S The Pentium Floating-Point Bug
- • 2.3 Input and Output
- • Input
- • Formatted Output
- • 2.4 PROBLEM SOLVING First Do It By Hand
- • WE 1 Computing Travel Time
- • HT 1 Carrying out Computations
- • WE 2 Computing the Cost of Stamps
- • 2.5 Strings
- • The string Type
- • Concatenation
- • String Input
- • String Functions
- • C&S International Alphabets and Unicode
Chapter 3: Decisions
- • 3.1 The if Statement
- • CE 1 A Semicolon After the if Condition
- • PT 1 Brace Layout
- • PT 2 Always Use Braces
- • PT 3 Tabs
- • PT 4 Avoid Duplication in Branches
- • ST 1 The Conditional Operator
- • 3.2 Comparing Numbers and Strings
- • CE 2 Confusing = and ==
- • CE 3 Exact Comparison of Floating-Point Numbers
- • PT 5 Compile with Zero Warnings
- • ST 2 Lexicographic Ordering of Strings
- • HT 1 Implementing an if Statement
- • WE 1 Extracting the Middle
- • C&S Dysfunctional Computerized Systems
- • 3.3 Multiple Alternatives
- • ST 3 The switch Statement
- • 3.4 Nested Branches
- • CE 4 The Dangling else Problem
- • PT 6 Hand-Tracing
- • 3.5 PROBLEM SOLVING Flowcharts
- • 3.6 PROBLEM SOLVING Test Cases
- • PT 7 Make a Schedule and Make Time for Unexpected Problems
- • 3.7 Boolean Variables and Operators
- • CE 5 Combining Multiple Relational Operators
- • CE 6 Confusing && and || Conditions
- • ST 4 Short-Circuit Evaluation of Boolean Operators
- • ST 5 De Morgan’s Law
- • 3.8 APPLICATION Input Validation
- • C&S Artificial Intelligence
Chapter 4: Loops
- • 4.1 The while Loop
- • CE 1 Infinite Loops
- • CE 2 Don’t Think “Are We There Yet?”
- • CE 3 Off-by-One Errors
- • C&S The First Bug
- • 4.2 PROBLEM SOLVING Hand-Tracing
- • 4.3 The for Loop
- • PT 1 Use for Loops for Their Intended Purpose Only
- • PT 2 Choose Loop Bounds That Match Your Task
- • PT 3 Count Iterations
- • 4.4 The do Loop
- • PT 4 Flowcharts for Loops
- • 4.5 Processing Input
- • Sentinel Values
- • Reading Until Input Fails
- • ST 1 Clearing the Failure State
- • ST 2 The Loop-and-a-Half Problem and the break Statement
- • ST 3 Redirection of Input and Output
- • 4.6 PROBLEM SOLVING Storyboards
- • 4.7 Common Loop Algorithms
- • Sum and Average Value
- • Counting Matches
- • Finding the First Match
- • Prompting Until a Match is Found
- • Maximum and Minimum
- • Comparing Adjacent Values
- • HT 1 Writing a Loop
- • WE 1 Credit Card Processing
- • 4.8 Nested Loops
- • WE 2 Manipulating the Pixels in an Image
- • 4.9 PROBLEM SOLVING Solve a Simpler Problem First
- • 4.10 Random Numbers and Simulations
- • Generating Random Numbers
- • Simulating Die Tosses
- • The Monte Carlo Method
- • C&S Digital Piracy
Chapter 5: Functions
- • 5.1 Functions as Black Boxes
- • 5.2 Implementing Functions
- • PT 1 Function Comments
- • 5.3 Parameter Passing
- • PT 2 Do Not Modify Parameter Variables
- • 5.4 Return Values
- • CE 1 Missing Return Value
- • ST 1 Function Declarations
- • HT 1 Implementing a Function
- • WE 1 Generating Random Passwords
- • WE 2 Using a Debugger
- • 5.5 Functions Without Return Values
- • 5.6 PROBLEM SOLVING Reusable Functions
- • 5.7 PROBLEM SOLVING Stepwise Refinement
- • PT 3 Keep Functions Short
- • PT 4 Tracing Functions
- • PT 5 Stubs
- • WE 3 Calculating a Course Grade
- • 5.8 Variable Scope and Global Variables
- • PT 6 Avoid Global Variables
- • 5.9 Reference Parameters
- • PT 7 Prefer Return Values to Reference Parameters
- • ST 2 Constant References
- • 5.10 Recursive Functions (Optional)
- • HT 2 Thinking Recursively
- • C&S The Explosive Growth of Personal Computers
Chapter 6: Arrays and Vectors
- • 6.1 Arrays
- • Defining Arrays
- • Accessing Array Elements
- • Partially Filled Arrays
- • CE 1 Bounds Errors
- • PT 1 Use Arrays for Sequences of Related Values
- • C&S Computer Viruses
- • 6.2 Common Array Algorithms
- • Filling
- • Copying
- • Sum and Average Value
- • Maximum and Minimum
- • Element Separators
- • Counting Matches
- • Linear Search
- • Removing an Element
- • Inserting an Element
- • Swapping Elements
- • Reading Input
- • ST 1 Sorting with the C++ Library
- • ST 2 A Sorting Algorithm
- • ST 3 Binary Search
- • 6.3 Arrays and Functions
- • ST 4 Constant Array Parameters
- • 6.4 PROBLEM SOLVING Adapting Algorithms
- • HT 1 Working with Arrays
- • WE 1 Rolling the Dice
- • 6.5 PROBLEM SOLVING Discovering Algorithms by Manipulating Physical Objects
- • 6.6 Two-Dimensional Arrays
- • Defining Two-Dimensional Arrays
- • Accessing Elements
- • Locating Neighboring Elements
- • Computing Row and Column Totals
- • Two-Dimensional Array Parameters
- • CE 2 Omitting the Column Size of a Two-Dimensional Array Parameter
- • WE 2 A World Population Table
- • 6.7 Vectors
- • Defining Vectors
- • Growing and Shrinking Vectors
- • Vectors and Functions
- • Vector Algorithms
- • Two-Dimensional Vectors
- • PT 2 Prefer Vectors over Arrays
- • ST 5 The Range-Based for Loop
Chapter 7: Pointers and Structures
- • 7.1 Defining and Using Pointers
- • Defining Pointers
- • Accessing Variables Through Pointers
- • Initializing Pointers
- • CE 1 Confusing Pointers with the Data to Which They Point
- • PT 1 Use a Separate Definition for Each Pointer Variable
- • ST 1 Pointers and References
- • 7.2 Arrays and Pointers
- • Arrays as Pointers
- • Pointer Arithmetic
- • Array Parameter Variables are Pointers
- • ST 2 Using a Pointer to Step Through an Array
- • CE 2 Returning a Pointer to a Local Variable
- • PT 2 Program Clearly, Not Cleverly
- • ST 3 Constant Pointers
- • 7.3 C and C++ Strings
- • The char Type
- • C Strings
- • Character Arrays
- • Converting Between C and C++ Strings
- • C++ Strings and the [] Operator
- • ST 4 Working with C Strings
- • 7.4 Dynamic Memory Allocation
- • CE 3 Dangling Pointers
- • CE 4 Memory Leaks
- • 7.5 Arrays and Vectors of Pointers
- • 7.6 PROBLEM SOLVING Draw a Picture
- • HT 1 Working with Pointers
- • WE 1 Producing a Mass Mailing
- • C&S Embedded Systems
- • 7.7 Structures
- • Structured Types
- • Structure Assignment and Comparison
- • Functions and Structures
- • Arrays of Structures
- • Structures with Array Members
- • Nested Structures
- • 7.8 Pointers and Structures
- • Pointers to Structures
- • Structures with Pointer Members
- • ST 5 Smart Pointers
Chapter 8: Streams
- • 8.1 Reading and Writing Text Files
- • Opening a Stream
- • Reading from a File
- • Writing to a File
- • A File Processing Example
- • 8.2 Reading Text Input
- • Reading Words
- • Reading Characters
- • Reading Lines
- • CE 1 Mixing >> and getline Input
- • ST 1 Stream Failure Checking
- • 8.3 Writing Text Output
- • ST 2 Unicode, UTF-8, and C++ Strings
- • 8.4 Parsing and Formatting Strings
- • 8.5 Command Line Arguments
- • C&S Encryption Algorithms
- • HT 1 Processing Text Files
- • WE 1 Looking for for Duplicates
- • 8.6 Random Access and Binary Files
- • Random Access
- • Binary Files
- • Processing Image Files
- • C&S Databases and Privacy
Chapter 9: Classes
- • 9.1 Object-Oriented Programming
- • 9.2 Implementing a Simple Class
- • 9.3 Specifying the Public Interface of a Class
- • CE 1 Forgetting a Semicolon
- • 9.4 Designing the Data Representation
- • 9.5 Member Functions
- • Implementing Member Functions
- • Implicit and Explicit Parameters
- • Calling a Member Function from a Member Function
- • PT 1 All Data Members Should Be Private; Most Member Functions Should Be Public
- • PT 2 const Correctness
- • 9.6 Constructors
- • CE 2 Trying to Call a Constructor
- • ST 1 Overloading
- • ST 2 Initializer Lists
- • ST 3 Universal and Uniform Initialization Syntax
- • 9.7 PROBLEM SOLVING Tracing Objects
- • HT 1 Implementing a Class
- • WE 1 Implementing a Bank Account Class
- • C&S Electronic Voting Machines
- • 9.8 PROBLEM SOLVING Discovering Classes
- • PT 3 Make Parallel Vectors into Vectors of Objects
- • 9.9 Separate Compilation
- • 9.10 Pointers to Objects
- • Dynamically Allocating Objects
- • The -> Operator
- • The this Pointer
- • 9.11 PROBLEM SOLVING Patterns for Object Data
- • Keeping a Total
- • Counting Events
- • Collecting Values
- • Managing Properties of an Object
- • Modeling Objects with Distinct States
- • Describing the Position of an Object
- • C&S Open Source and Free Software
Chapter 10: Inheritance
- • 10.1 Inheritance Hierarchies
- • 10.2 Implementing Derived Classes
- • CE 1 Private Inheritance
- • CE 2 Replicating Base-Class Members
- • PT 1 Use a Single Class for Variation in Values, Inheritance for Variation in Behavior
- • ST 1 Calling the Base-Class Constructor
- • 10.3 Overriding Member Functions
- • CE 3 Forgetting the Base-Class Name
- • 10.4 Virtual Functions and Polymorphism
- • The Slicing Problem
- • Pointers to Base and Derived Classes
- • Virtual Functions
- • Polymorphism
- • PT 2 Don’t Use Type Tags
- • CE 4 Slicing an Object
- • CE 5 Failing to Override a Virtual Function
- • ST 2 Virtual Self-Calls
- • HT 1 Developing an Inheritance Hierarchy
- • WE 1 Implementing an Employee Hierarchy for Payroll Processing
- • C&S Who Controls the Internet?
Chapter 11: Recursion
- • 11.1 Triangle Numbers
- • CE 1 Tracing Through Recursive Functions
- • CE 2 Infinite Recursion
- • HT 1 Thinking Recursively
- • WE 1 Finding Files
- • 11.2 Recursive Helper Functions
- • 11.3 The Efficiency of Recursion
- • 11.4 Permutations
- • 11.5 Mutual Recursion
- • 11.6 Backtracking
- • WE 2 Towers of Hanoi
- • C&S The Limits of Computation
Chapter 12: Sorting and Searching
- • 12.1 Selection Sort
- • 12.2 Profiling the Selection Sort Algorithm
- • 12.3 Analyzing the Performance of the Selection Sort Algorithm
- • ST 1 Oh, Omega, and Theta
- • ST 2 Insertion Sort
- • 12.4 Merge Sort
- • 12.5 Analyzing the Merge Sort Algorithm
- • ST 3 The Quicksort Algorithm
- • 12.6 Searching
- • Linear Search
- • Binary Search
- • PT 1 Library Functions for Sorting and Binary Search
- • ST 4 Defining an Ordering for Sorting Objects
- • 12.7 PROBLEM SOLVING Estimating the Running Time of an Algorithm
- • Linear Time
- • Quadratic Time
- • The Triangle Pattern
- • Logarithmic Time
- • WE 1 Enhancing the Insertion Sort Algorithm
- • C&S The First Programmer
Chapter 13: Advanced C++
- • 13.1 Operator Overloading
- • Operator Functions
- • Overloading Comparison Operators
- • Input and Output
- • Operator Members
- • ST 1 Overloading Increment and Decrement Operators
- • ST 2 Implicit Type Conversions
- • ST 3 Returning References
- • WE 1 A Fraction Class
- • 13.2 Automatic Memory Management
- • Constructors That Allocate Memory
- • Destructors
- • Overloading the Assignment Operator
- • Copy Constructors
- • PT 1 Use Reference Parameters to Avoid Copies
- • CE 1 Defining a Destructor Without the Other Two Functions of the “Big Three”
- • ST 4 Virtual Destructors
- • ST 5 Suppressing Automatic Generation of Memory Management Functions
- • ST 6 Move Operations
- • ST 7 Shared Pointers
- • WE 2 Tracing Memory Management of Strings
- • 13.3 Templates
- • Function Templates
- • Class Templates
- • ST 8 Non-Type Template Parameters
Chapter 14: Linked Lists, Stacks, and Queues
- • 14.1 Using Linked Lists
- • 14.2 Implementing Linked Lists
- • The Classes for Lists, Node, and Iterators
- • Implementing Iterators
- • Implementing Insertion and Removal
- • WE 1 Implementing a Linked List Template
- • 14.3 The Efficiency of List, Array, and Vector Operations
- • 14.4 Stacks and Queues
- • 14.5 Implementing Stacks and Queues
- • Stacks as Linked Lists
- • Stacks as Arrays
- • Queues as Linked Lists
- • Queues as Circular Arrays
- • 14.6 Stack and Queue Applications
- • Balancing Parentheses
- • Evaluating Reverse Polish Expressions
- • Evaluating Algebraic Expressions
- • Backtracking
- • ST 1 Reverse Polish Notation
Chapter 15: Sets, Maps, and Hash Tables
- • 15.1 Sets
- • 15.2 Maps
- • PT 1 Use the auto Type for Iterators
- • ST 1 Multisets and Multimaps
- • WE 1 Word Frequency
- • 15.3 Implementing a Hash Table
- • Hash Codes
- • Hash Tables
- • Finding an Element
- • Adding and Removing Elements
- • Iterating over a Hash Table
- • ST 2 Implementing Hash Functions
- • ST 3 Open Addressing
Chapter 16: Tree Structures
- • 16.1 Basic Tree Concepts
- • 16.2 Binary Trees
- • Binary Tree Examples
- • Balanced Trees
- • A Binary Tree Implementation
- • WE 1 Building a Huffman Tree
- • 16.3 Binary Search Trees
- • The Binary Search Property
- • Insertion
- • Removal
- • Efficiency of the Operations
- • 16.4 Tree Traversal
- • Inorder Traversal
- • Preorder and Postorder Traversals
- • The Visitor Pattern
- • Depth-First and Breadth-First Search
- • Tree Iterators
- • 16.5 Red-Black Trees
- • Basic Properties of Red-Black Trees
- • WE 2 Implementing a Red-Black Tree
Chapter 17: Priority Queues and Heaps
- • 17.1 Priority Queues
- • WE 1 Simulating a Queue of Waiting Customers
- • 17.2 Heaps
- • 17.3 The Heapsort Algorithm
Chapter Appendix A: Reserved Word Summary
Chapter Appendix B: Operator Summary
Chapter Appendix C: Character Codes
Chapter Appendix D: C++ Library Summary
Chapter Appendix E: C++ Language Coding Guidelines
Chapter Appendix F: Number Systems and Bit and Shift Operations
Customer Reviews
0.0
0 reviews
5 stars
0
4 stars
0
3 stars
0
2 stars
0
1 stars
0
No reviews yet. Be the first to review this book!
Write a Review
Reviewed by GradeFocus Editorial Team
