FREE SHIPPING BOTH WAYS
ON EVERY ORDER!
LIST PRICE:
$123.00

Sorry, this item is currently unavailable.

Starting Out with C++ : From Control Structures Through Objects

ISBN: 9780321409393 | 0321409396
Edition: 6th
Format: Paperback w/CD
Publisher: Addison Wesley
Pub. Date: 1/1/2009

Why Rent from Knetbooks?

Because Knetbooks knows college students. Our rental program is designed to save you time and money. Whether you need a textbook for a semester, quarter or even a summer session, we have an option for you. Simply select a rental period, enter your information and your book will be on its way!

Top 5 reasons to order all your textbooks from Knetbooks:

  • We have the lowest prices on thousands of popular textbooks
  • Free shipping both ways on ALL orders
  • Most orders ship within 48 hours
  • Need your book longer than expected? Extending your rental is simple
  • Our customer support team is always here to help
SummaryTable of Contents
Tony Gaddis's accessible, step-by-step framework defines Starting Out With C++: Control Structures through Objects (formerly called Standard Version), and has made this book the #1 choice with instructors who emphasize problem-solving and program design in their introduction to programming course. In Control Structures through Objects, Gaddis takes a problem-solving approach, motivating students to understand the programming logic behind developing quality programs using the C++ language. Procedural programming is thoroughly covered before obje... MORE
Prefacexiii
Introduction to Computers and Programming
1(28)
Why Program?
1(1)
... MORE
Computer Systems: Hardware and Software
2(4)
Programs and Programming Languages
6(6)
What Is a Program Made of?
12(4)
Input, Processing, and Output
16(1)
The Programming Process
17(4)
Procedural and Object-Oriented Programming
21(8)
Introduction to C++
29(52)
The Parts of a C++ Program
29(4)
The cout Object
33(4)
The #include Directive
37(2)
Variables and Literals
39(3)
Identifiers
42(2)
Integer Data Types
44(4)
The char Data Type
48(5)
Floating-Point Data Types
53(4)
The bool Data Type
57(1)
Determining the Size of a Data Type
58(1)
Variable Assignments and Initialization
59(1)
Scope
60(1)
Arithmetic Operators
61(4)
Comments
65(2)
Focus on Software Engineering: Programming Style
67(2)
If You Plan to Continue in Computer Science: Standard and Prestandard C++
69(12)
Expressions and Interactivity
81(82)
The cin Object
81(8)
Mathematical Expressions
89(8)
When You Mix Apples and Oranges: Type Conversion
97(2)
Overflow and Underflow
99(1)
Type Casting
100(4)
Named Constants
104(5)
Multiple Assignment and Combined Assignment
109(4)
Formatting Output
113(10)
Formatted Input
123(5)
Focus on Object-Oriented Programming: More About Member Functions
128(1)
More Mathematical Library Functions
128(4)
Focus on Debugging: Hand Tracing a Program
132(2)
Focus on Problem Solving: A Case Study
134(4)
Introduction to File Input and Output
138(25)
Making Decisions
163(84)
Relational Operators
163(5)
The if Statement
168(8)
Flags
176(1)
Expanding the if Statement
177(4)
The if/else Statement
181(3)
The if/else if Statement
184(5)
Using a Trailing else
189(1)
Menus
190(2)
Focus on Software Engineering: Nested if Statements
192(6)
Logical Operators
198(6)
Checking Numeric Ranges with Logical Operators
204(2)
Focus on Software Engineering: Validating User Input
206(2)
More About Variable Definitions and Scope
208(4)
Comparing Strings
212(5)
The Conditional Operator
217(4)
The switch Statement
221(9)
Testing for File Open Errors
230(17)
Looping
247(52)
The Increment and Decrement Operators
247(5)
Introduction to Loops: The while Loop
252(5)
Using the while Loop for Input Validation
257(3)
Counters
260(1)
The do-while Loop
261(5)
The for Loop
266(9)
Keeping a Running Total
275(1)
Sentinels
276(2)
Using a Loop to Read Data from a File
278(3)
Focus on Software Engineering: Deciding Which Loop to Use
281(1)
Nested Loops
281(3)
Breaking Out of a Loop
284(2)
The continue Statement
286(13)
Functions
299(78)
Focus on Software Engineering: Modular Programming
299(2)
Defining and Calling Functions
301(8)
Function Prototypes
309(2)
Sending Data into a Function
311(5)
Passing Data by Value
316(2)
Focus on Software Engineering: Using Functions in a Menu-Driven Program
318(4)
The return Statement
322(2)
Returning a Value from a Function
324(6)
Returning a Boolean Value
330(2)
Local and Global Variables
332(7)
Static Local Variables
339(4)
Default Arguments
343(4)
Using Reference Variables as Parameters
347(5)
Overloading Functions
352(5)
The exit( ) Function
357(2)
Stubs and Drivers
359(18)
Arrays
377(78)
Arrays Hold Multiple Values
377(2)
Accessing Array Elements
379(7)
No Bounds Checking in C++
386(3)
Array Initialization
389(5)
Processing Array Contents
394(8)
Focus on Software Engineering: Using Parallel Arrays
402(3)
Arrays as Function Arguments
405(10)
Two-Dimensional Arrays
415(7)
Arrays of Strings
422(2)
Arrays with Three or More Dimensions
424(2)
Focus on Problem Solving and Program Design: A Case Study
426(2)
If You Plan to Continue in Computer Science: Introduction to the STL vector
428(27)
Searching and Sorting Arrays
455(40)
Focus on Software Engineering: Introduction to Search Algorithms
455(7)
Focus on Problem Solving and Program Design: A Case Study
462(6)
Focus on Software Engineering: Introduction to Sorting Algorithms
468(8)
Focus on Problem Solving and Program Design: A Case Study
476(8)
If You Plan to Continue in Computer Science: Sorting and Searching vectors
484(11)
Pointers
495(48)
Getting the Address of a Variable
495(2)
Pointer Variables
497(7)
The Relationship Between Arrays and Pointers
504(4)
Pointer Arithmetic
508(2)
Initializing Pointers
510(1)
Comparing Pointers
511(2)
Pointers as Function Parameters
513(9)
Focus on Software Engineering: Dynamic Memory Allocation
522(4)
Focus on Software Engineering: Returning Pointers from Functions
526(4)
Focus on Problems Solving and Program Design: A Case Study
530(13)
Characters, Strings, and the string Class
543(48)
Character Testing
543(4)
Character Case Conversion
547(3)
Review of the Internal Storage of C-Strings
550(3)
Library Functions for Working with C-Strings
553(8)
String/Numeric Conversion Functions
561(5)
Focus on Software Engineering: Writing Your Own C-String-Handling Functions
566(6)
The C++ string Class
572(10)
Focus on Problem Solving and Program Design: A Case Study
582(9)
Structured Data
591(64)
Abstract Data Types
591(2)
Focus on Software Engineering: Combining Data into Structures
593(3)
Accessing Structure Members
596(5)
Initializing a Structure
601(4)
Arrays of Structures
605(3)
Focus on Software Engineering: Nested Structures
608(4)
Structures as Function Arguments
612(3)
Returning a Structure from a Function
615(3)
Pointers to Structures
618(3)
Focus on Software Engineering: When to Use . , When to Use ->, and When to Use *
621(2)
Unions
623(4)
Enumerated Data Types
627(28)
Advanced File Operations
655(56)
File Operations
655(7)
File Output Formatting
662(3)
Passing File Stream Objects to Functions
665(2)
More Detailed Error Testing
667(3)
Member Functions for Reading and Writing Files
670(7)
Focus on Software Engineering: Working with Multiple Files
677(1)
Binary Files
678(6)
Creating Records with Structures
684(4)
Random-Access Files
688(8)
Opening a File for Both Input and Output
696(15)
Introduction to Classes
711(96)
Procedural and Object-Oriented Programming
711(7)
Introduction to Classes
718(5)
Defining an Instance of a Class
723(11)
Why Have Private Members?
734(1)
Focus on Software Engineering: Separating Class Specification from Implementation
735(6)
Inline Member Functions
741(3)
Constructors
744(4)
Passing Arguments to Constructors
748(8)
Destructors
756(4)
Overloading Constructors
760(4)
Private Member Functions
764(2)
Arrays of Objects
766(4)
Focus on Problem Solving and Program Design: An OOP Case Study
770(7)
Focus on Object-Oriented Programming: Creating an Abstract Array Data Type
777(4)
Focus on Object-Oriented Design: The Unified Modeling Language (UML)
781(3)
Focus on Object-Oriented Design: Finding the Classes and Their Responsibilities
784(23)
More About Classes
807(70)
Instance and Static Members
807(8)
Friends of Classes
815(5)
Memberwise Assignment
820(1)
Copy Constructors
821(4)
Operator Overloading
825(27)
Object Conversion
852(2)
Aggregation
854(6)
Focus on Object-Oriented Design: Class Collaborations
860(17)
Inheritance, Polymorphism, and Virtual Functions
877(74)
What Is Inheritance?
877(9)
Protected Members and Class Access
886(6)
Constructors and Destructors in Base and Derived Classes
892(7)
Redefining Base Class Functions
899(4)
Class Hierarchies
903(6)
Polymorphism and Virtual Member Functions
909(15)
Abstract Base Classes and Pure Virtual Functions
924(7)
Multiple Inheritance
931(20)
Exceptions, Templates, and the Standard Template Library (STL)
951(56)
Exceptions
951(19)
Function Templates
970(6)
Focus on Software Engineering: Where to Start When Defining Templates
976(1)
Class Templates
977(10)
Introduction to the Standard Template Library (STL)
987(20)
Linked Lists
1007(40)
Introduction to the Linked List ADT
1007(2)
Linked List Operations
1009(17)
A Linked List Template
1026(12)
Variations of the Linked List
1038(1)
The STL list Container
1039(8)
Stacks and Queues
1047(40)
Introduction to the Stack ADT
1047(11)
Dynamic Stacks
1058(5)
The STL stack Container
1063(2)
Introduction to the Queue ADT
1065(8)
Dynamic Queues
1073(4)
The STL deque and queue Containers
1077(10)
Recursion
1087(38)
Introduction to Recursion
1087(5)
Solving Problems with Recursion
1092(7)
Focus on Problem Solving and Program Design: The Recursive gcd Function
1099(1)
Focus on Problem Solving and Program Design: Solving Recursively Defined Problems
1100(2)
Focus on Problem Solving and Program Design: Recursive Linked List Operations
1102(3)
Focus on Problem Solving and Program Design: A Recursive Binary Search Function
1105(3)
The Towers of Hanoi
1108(3)
Focus on Problem Solving and Program Design: The QuickSort Algorithm
1111(5)
Exhaustive Algorithms
1116(2)
Focus on Software Engineering: Recursion vs. Iteration
1118(7)
Binary Trees
1125(26)
Definition and Applications of Binary Trees
1125(3)
Binary Search Tree Operations
1128(17)
Template Considerations for Binary Search Trees
1145(6)
Appendix A: The ASCII Character Set1151(4)
Appendix B: Operator Precedence and Associativity1155(2)
Index1157

Related Products


  • Starting Out with C++
    Starting Out with C++
  • Starting Out with C++ : From Control Structures Through Objects
    Starting Out with C++ : From C...
  • Starting Out with C++ : From Control Structures through Objects
    Starting Out with C++ : From C...
  • Starting Out with C++ Brief : From Control Structures through Objects
    Starting Out with C++ Brief : ...
  • Starting Out with C++ From Control Structures through Objects plus MyProgrammingLab with Pearson eText -- Access Card
    Starting Out with C++ From Con...
  • Starting Out with C++ From Control Structures through Objects, Brief Edition
    Starting Out with C++ From Con...
  • Starting Out with C++ From Control Structures through Objects, Brief Edition plus MyProgrammingLab with Pearson eText - Access Card
    Starting Out with C++ From Con...
  • Starting Out with C++, Standard Version 2005 Update Package
    Starting Out with C++, Standar...


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