Description
A clear and student-friendly way to teach the fundamentals of C++
Starting Out with C++: From Control Structures through Objects covers control structures, functions, arrays, and pointers before objects and classes in Tony Gaddis’s hallmark accessible, step-by-step presentation. His books help beginning students understand the important details necessary to become skilled programmers at an introductory level. Gaddis motivates the study of both programming skills and the C++ programming language by presenting all the details needed to understand the “how” and the “why”–but never losing sight of the fact that most beginners struggle with this material. His approach is gradual and highly accessible, ensuring that students understand the logic behind developing high-quality programs. As with all Gaddis texts, clear and easy-to-read code listings, concise and practical real-world examples, and an abundance of exercises appear in every chapter. Updates to the 9th Edition include revised, improved problems throughout and a new chapter featuring completely rewritten and expanded material on the Standard Template Library (STL).
------------------------------------------------
About the Book
The material on the Standard Template Library (STL) has been completely rewritten and expanded into its own chapter. Previously, Chapter 16 covered exceptions, templates, and covered the STL briefly. In this edition, Chapter 16 covers exceptions and templates, and Chapter 17 is a new chapter dedicated to the STL. The new chapter covers the following topics:
The array and vector classes
The various types of iterators
Emplacement versus insertion
The map, multimap, and unordered_map Classes
The set, multiset, and unordered_set Classes
Sorting and searching algorithms
Permutation algorithms
Set algorithms
Using function pointers with STL algorithms
Function objects, or functors
Lambda expressions
------
Chapter 2 now includes a discussion of alternative forms of variable initialization, including functional notation, and
brace notation (also known as uniform initialization).
Chapter 3 now mentions the round function, introduced in C++ 11.
Chapter 7 now introduces array initialization much earlier.
In Chapter 8, the bubble sort algorithm has been rewritten and improved.
A new example of sorting and searching a vector of strings has been added to Chapter 8.
In Chapter 9, the section on smart pointers now gives an overview of shared_ptrs and weak_ptrs, in addition to the existing coverage of unique_ptrs.
In Chapter 10, a new In the Spotlight section on string tokenizing has been added.
Chapter 10 now covers the string-to-number conversion functions that were introduced in C++ 11.
The material on unions that previously appeared in Chapter 11 has been moved to Appendix K, available on the book’s companion Website.
Chapter 13 has new sections covering:
Member initialization lists.
In-place initialization.
Constructor delegation.
Several new topics were added to Chapter 14, including:
Rvalue references and move semantics.
Checking for self-assignment when overloading the = operator.
Using member initialization lists in aggregate classes.
Chapter 15 includes a new section on constructor inheritance.
Several new programming problems have been added throughout the book.
Author(s): Tony Gaddis
Edition: 9
Publisher: Pearson
Year: 2019
Language: English
Commentary: True PDF.
Pages: 1347
Tags: C++ C++11 iso cpp object-oriented compilers
Cover
Inside Front Cover
Title Page
Copyright Page
Contents at a Glance
Contents
Preface
CHAPTER 1 Introduction to Computers and Programming
1.1 Why Program?
1.2 Computer Systems: Hardware and Software
1.3 Programs and Programming Languages
1.4 What Is a Program Made of?
1.5 Input, Processing, and Output
1.6 The Programming Process
1.7 Procedural and Object-Oriented Programming
Review Questions and Exercises
CHAPTER 2 Introduction to C++
2.1 The Parts of a C++ Program
2.2 The cout Object
2.3 The #include Directive
2.4 Variables, Literals, and Assignment Statements
2.5 Identifiers
2.6 Integer Data Types
2.7 The char Data Type
2.8 The C++ string Class
2.9 Floating-Point Data Types
2.10 The bool Data Type
2.11 Determining the Size of a Data Type
2.12 More about Variable Assignments and Initialization
2.13 Scope
2.14 Arithmetic Operators
2.15 Comments
2.16 Named Constants
2.17 Programming Style
Review Questions and Exercises
Programming Challenges
CHAPTER 3 Expressions and Interactivity
3.1 The cin Object
3.2 Mathematical Expressions
3.3 When You Mix Apples and Oranges: Type Conversion
3.4 Overflow and Underflow
3.5 Type Casting
3.6 Multiple Assignment and Combined Assignment
3.7 Formatting Output
3.8 Working with Characters and string Objects
3.9 More Mathematical Library Functions
3.10 Focus on Debugging: Hand Tracing a Program
3.11 Focus on Problem Solving: A Case Study
Review Questions and Exercises
Programming Challenges
CHAPTER 4 Making Decisions
4.1 Relational Operators
4.2 The if Statement
4.3 Expanding the if Statement
4.4 The if/else Statement
4.5 Nested if Statements
4.6 The if/else if Statement
4.7 Flags
4.8 Logical Operators
4.9 Checking Numeric Ranges with Logical Operators
4.10 Menus
4.11 Focus on Software Engineering: Validating User Input
4.12 Comparing Characters and Strings
4.13 The Conditional Operator
4.14 The switch Statement
4.15 More about Blocks and Variable Scope
Review Questions and Exercises
Programming Challenges
CHAPTER 5 Loops and Files
5.1 The Increment and Decrement Operators
5.2 Introduction to Loops: The while Loop
5.3 Using the while Loop for Input Validation
5.4 Counters
5.5 The do-while Loop
5.6 The for Loop
5.7 Keeping a Running Total
5.8 Sentinels
5.9 Focus on Software Engineering: Deciding Which Loop to Use
5.10 Nested Loops
5.11 Using Files for Data Storage
5.12 Optional Topics: Breaking and Continuing a Loop
Review Questions and Exercises
Programming Challenges
CHAPTER 6 Functions
6.1 Focus on Software Engineering: Modular Programming
6.2 Defining and Calling Functions
6.3 Function Prototypes
6.4 Sending Data into a Function
6.5 Passing Data by Value
6.6 Focus on Software Engineering: Using Functions in a Menu-Driven Program
6.7 The return Statement
6.8 Returning a Value from a Function
6.9 Returning a Boolean Value
6.10 Local and Global Variables
6.11 Static Local Variables
6.12 Default Arguments
6.13 Using Reference Variables as Parameters
6.14 Overloading Functions
6.15 The exit() Function
6.16 Stubs and Drivers
Review Questions and Exercises
Programming Challenges
CHAPTER 7 Arrays and Vectors
7.1 Arrays Hold Multiple Values
7.2 Accessing Array Elements
7.3 No Bounds Checking in C++
7.4 The Range-Based for Loop
7.5 Processing Array Contents
7.6 Focus on Software Engineering: Using Parallel Arrays
7.7 Arrays as Function Arguments
7.8 Two-Dimensional Arrays
7.9 Arrays with Three or More Dimensions
7.10 Focus on Problem Solving and Program Design: A Case Study
7.11 Introduction to the STL vector
Review Questions and Exercises
Programming Challenges
CHAPTER 8 Searching and Sorting Arrays
8.1 Focus on Software Engineering: Introduction to Search Algorithms
8.2 Focus on Problem Solving and Program Design: A Case Study
8.3 Focus on Software Engineering: Introduction to Sorting Algorithms
8.4 Focus on Problem Solving and Program Design: A Case Study
8.5 Sorting and Searching vectors
Review Questions and Exercises
Programming Challenges
CHAPTER 9 Pointers
9.1 Getting the Address of a Variable
9.2 Pointer Variables
9.3 The Relationship between Arrays and Pointers
9.4 Pointer Arithmetic
9.5 Initializing Pointers
9.6 Comparing Pointers
9.7 Pointers as Function Parameters
9.8 Dynamic Memory Allocation
9.9 Returning Pointers from Functions
9.10 Using Smart Pointers to Avoid Memory Leaks
9.11 Focus on Problem Solving and Program Design: A Case Study
Review Questions and Exercises
Programming Challenges
CHAPTER 10 Characters, C-Strings, and More about the string Class
10.1 Character Testing
10.2 Character Case Conversion
10.3 C-Strings
10.4 Library Functions for Working with C-Strings
10.5 String/Numeric Conversion Functions
10.6 Focus on Software Engineering: Writing Your Own C-String-Handling Functions
10.7 More about the C++ string Class
10.8 Focus on Problem Solving and Program Design: A Case Study
Review Questions and Exercises
Programming Challenges
CHAPTER 11 Structured Data
11.1 Abstract Data Types
11.2 Structures
11.3 Accessing Structure Members
11.4 Initializing a Structure
11.5 Arrays of Structures
11.6 Focus on Software Engineering: Nested Structures
11.7 Structures as Function Arguments
11.8 Returning a Structure from a Function
11.9 Pointers to Structures
11.10 Focus on Software Engineering: When to Use ., When to Use ->, and When to Use *
11.11 Enumerated Data Types
Review Questions and Exercises
Programming Challenges
CHAPTER 12 Advanced File Operations
12.1 File Operations
12.2 File Output Formatting
12.3 Passing File Stream Objects to Functions
12.4 More Detailed Error Testing
12.5 Member Functions for Reading and Writing Files
12.6 Focus on Software Engineering: Working with Multiple Files
12.7 Binary Files
12.8 Creating Records with Structures
12.9 Random-Access Files
12.10 Opening a File for Both Input and Output
Review Questions and Exercises
Programming Challenges
CHAPTER 13 Introduction to Classes
13.1 Procedural and Object-Oriented Programming
13.2 Introduction to Classes
13.3 Defining an Instance of a Class
13.4 Why Have Private Members?
13.5 Focus on Software Engineering: Separating Class Specification from Implementation
13.6 Inline Member Functions
13.7 Constructors
13.8 Passing Arguments to Constructors
13.9 Destructors
13.10 Overloading Constructors
13.11 Private Member Functions
13.12 Arrays of Objects
13.13 Focus on Problem Solving and Program Design: An OOP Case Study
13.14 Focus on Object-Oriented Programming: Simulating Dice with Objects
13.15 Focus on Object-Oriented Design: The Unified Modeling Language (UML)
13.16 Focus on Object-Oriented Design: Finding the Classes and Their Responsibilities
Review Questions and Exercises
Programming Challenges
CHAPTER 14 More about Classes
14.1 Instance and Static Members
14.2 Friends of Classes
14.3 Memberwise Assignment
14.4 Copy Constructors
14.5 Operator Overloading
14.6 Object Conversion
14.7 Aggregation
14.8 Focus on Object-Oriented Design: Class Collaborations
14.9 Focus on Object-Oriented Programming: Simulating the Game of Cho-Han
14.10 Rvalue References and Move Semantics
Review Questions and Exercises
Programming Challenges
CHAPTER 15 Inheritance, Polymorphism, and Virtual Functions
15.1 What Is Inheritance?
15.2 Protected Members and Class Access
15.3 Constructors and Destructors in Base and Derived Classes
15.4 Redefining Base Class Functions
15.5 Class Hierarchies
15.6 Polymorphism and Virtual Member Functions
15.7 Abstract Base Classes and Pure Virtual Functions
15.8 Multiple Inheritance
Review Questions and Exercises
Programming Challenges
CHAPTER 16 Exceptions and Templates
16.1 Exceptions
16.2 Function Templates
16.3 Focus on Software Engineering: Where to Start When Defining Templates
16.4 Class Templates
Review Questions and Exercises
Programming Challenges
CHAPTER 17 The Standard Template Library
17.1 Introduction to the Standard Template Library
17.2 STL Container and Iterator Fundamentals
17.3 The vector Class
17.4 The map, multimap, and unordered_map Classes
17.5 The set, multiset, and unordered_set Classes
17.6 Algorithms
17.7 Introduction to Function Objects and Lambda Expressions
Review Questions and Exercises
Programming Challenges
CHAPTER 18 Linked Lists
18.1 Introduction to the Linked List ADT
18.2 Linked List Operations
18.3 A Linked List Template
18.4 Variations of the Linked List
18.5 The STL list and forward_list Containers
Review Questions and Exercises
Programming Challenges
CHAPTER 19 Stacks and Queues
19.1 Introduction to the Stack ADT
19.2 Dynamic Stacks
19.3 The STL stack Container
19.4 Introduction to the Queue ADT
19.5 Dynamic Queues
19.6 The STL deque and queue Containers
Review Questions and Exercises
Programming Challenges
CHAPTER 20 Recursion
20.1 Introduction to Recursion
20.2 Solving Problems with Recursion
20.3 Focus on Problem Solving and Program Design: The Recursive gcd Function
20.4 Focus on Problem Solving and Program Design: Solving Recursively Defined Problems
20.5 Focus on Problem Solving and Program Design: Recursive Linked List Operations
20.6 Focus on Problem Solving and Program Design: A Recursive Binary Search Function
20.7 The Towers of Hanoi
20.8 Focus on Problem Solving and Program Design: The QuickSort Algorithm
20.9 Exhaustive Algorithms
20.10 Focus on Software Engineering: Recursion versus Iteration
Review Questions and Exercises
Programming Challenges
CHAPTER 21 Binary Trees
21.1 Definition and Applications of Binary Trees
21.2 Binary Search Tree Operations
21.3 Template Considerations for Binary Search Trees
Review Questions and Exercises
Programming Challenges
Appendix A: The ASCII Character Set
Appendix B: Operator Precedence and Associativity
Quick References
Index
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
Z
Credit
Back Cover
