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

Sorry, this item is currently unavailable.

Starting Out With C++

ISBN: 9781576760345 | 1576760340
Edition: 2ND
Format: Paperback
Publisher: Scott Jones
Pub. Date: 10/1/1999

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
Starting Out with C++ Alternate teaches C++ from the ground up, and assumes no prior background in programming. In Starting Out With C++ Alternate, Gaddis makes a very detailed and slow-paced presentation of both programming and C++ syntax concepts so all readers will be able to follow along. This version of the text gives an early introduction to classes and objects. The book includes the hallmark pedagogocial features that readers of Gaddis books have come to expect. Readers who are new to programming, as well as those with prior work in other languages will find this text beneficial.
Prefaceiii
Acknowledgmentsvii
About the Authorviii
Introduction to Computers and Programming
1(28)
... MORE
Why Program?
1(1)
Computer Systems: Hardware and Software
2(4)
Programs and Programming Languages
6(5)
What is a Program Made of?
11(4)
Input, Processing, and Output
15(2)
The Programming Process
17(4)
Procedural and Object-Oriented Programming
21(8)
Serendipity Booksellers Software Design Project---Part 1: A Problem-Solving Exercise
26(3)
Introduction to C++
29(50)
The Parts of a C++ Program
29(4)
The cout Object
33(4)
The #include Directive
37(2)
Variables and Contants
39(4)
Focus on Software Engineering: Identifiers
43(2)
Integer Data Types
45(5)
The char Data Type
50(4)
Floating Point Data Types
54(3)
The bool Data Type
57(1)
Focus on Software Engineering: Determining the Size of Data Types
58(1)
Focus on Software Engineering: Variable Assignments and Initialization
59(1)
Focus on Software Engineering: Scope
60(1)
Arithmetic Operators
61(3)
Comments
64(4)
Focus on Software Engineering: Programming Style
68(11)
Serendipity Booksellers Software Development Project---Part 2: A Problem-Solving Exercise
74(5)
Expressions and Interactivity
79(76)
The cin Object
79(8)
Focus on Software Engineering: Mathematical Expressions
87(8)
When You Mix Apples and Oranges: Type Coercion
95(2)
Overflow and Underflow
97(2)
The Typecast Operator
99(3)
The Power of Constants
102(5)
Multiple Assignment and Combined Assignment
107(5)
Formatting Output
112(15)
Formatted Input
127(5)
More Mathematical Library Functions
132(5)
Focus on Problem Solving: A Case Study
137(18)
Serendipity Booksellers Software Development Project---Part 3: A Problem-Solving Exercise
153(2)
Making Decisions
155(90)
Relational Operators
155(6)
The if Statement
161(6)
Flags
167(2)
Expanding the if Statement
169(4)
The if/else Statement
173(3)
The if/else if Statement
176(6)
Using a Trailing else
182(2)
Focus on Software Engineering: Menus
184(2)
Focus on Software Engineering: Nested if Statements
186(5)
Logical Operators
191(7)
Checking Numeric Ranges With Logical Operators
198(1)
Focus on Software Engineering: Validating User Input
199(2)
More About Variable Declarations and Scope
201(5)
Comparing Strings
206(5)
The Conditional Operator
211(5)
The switch Statement
216(9)
Focus on Problem Solving and Program Design: A Case Study
225(20)
Review Questions
228(14)
Serendipity Booksellers Software Development Project---Part 4: A Problem-Solving Exercise
242(3)
Looping
245(50)
The Increment and Decrement Operators
245(5)
Introduction to Loops---The while Loop
250(4)
Counters
254(3)
Letting the User Control the Loop
257(1)
Keeping a Running Total
258(1)
Sentinels
259(3)
The do-while Loop and for Loops
262(10)
Focus on Software Engineering: Deciding Which Loop to Use
272(1)
Focus on Sotfware Engineering: Nested Loops
272(3)
Breaking Out of a Loop
275(2)
The continue Statement
277(2)
Using Loops for Input Validation
279(2)
Focus on Problem Solving and Program Design: A Case Study
281(14)
Serendipity Booksellers Software Development Project---Part 5: A Problem Solving Exercise
294(1)
Functions
295(84)
Focus on Software Engineering: Breaking Up Your Programs
295(1)
Defining and Calling Functions
296(8)
Sending Information Into a Function
304(4)
Changing the Value of a Parameter
308(2)
Function Prototypes
310(2)
Focus on Software Engineering: Using Functions in a Menu-Driven Program
312(4)
Local and Global Variables
316(7)
Static Variables Local Variables
323(3)
Default Arguments
326(4)
Using Reference Variables as Parameters
330(5)
The return Statement
335(1)
Returning a Value From a Function
336(4)
Returning Boolean Values
340(1)
Overloaded Functions
341(5)
The exit () Function
346(2)
Focus on Software Engineering: Multi-File Programs
348(6)
Stubs and Drivers
354(2)
Focus on Problem Solving and Program Design: A Case Study
356(23)
Serendipity Booksellers Software Development Project---Part 6: A Problem-Solving Exercise
374(5)
Arrays
379(56)
Arrays Hold Multiple Values
379(2)
Accessing Array Elements
381(4)
No Bounds Checking in C++
385(3)
Array Initialization
388(6)
Processing Array Contents
394(4)
Focus on Software Engineering: Using Parallel Arrays
398(3)
Thou Shall Not Assign
401(1)
Arrays as Function Arguments
402(7)
Two-dimensional Arrays
409(6)
Arrays of Strings
415(2)
Focus on Problem Solving and Program Design: A Case Study
417(2)
Focus on Problem Solving and Program Design: A Case Study
419(16)
Serendipity Booksellers Software Development Project---Part 7: A Problem-Solving Exercise
431(4)
Searching and Sorting Arrays
435(36)
Focus on Software Engineering: Introduction to Search Algorithms
435(6)
Focus on Problem Solving and Program Design: A Case Study
441(7)
Focus on Software Engineering: Introduction to Sorting Algorithms
448(8)
Focus on Problem Solving and Program Design: A Case Study
456(15)
Serendipity Booksellers Software Development Project---Part 8: A Problem-Solving Exercise
468(3)
Pointers
471(40)
Getting the Address of a Variable
471(2)
Pointer Variables
473(4)
The Relationship Between Arrays and Pointers
477(4)
Pointer Arithmetic
481(2)
Initializing Pointers
483(2)
Comparing Pointers
485(1)
Pointers as Function Parameters
486(5)
Focus on Software Engineering: Dynamic Memory Allocation
491(3)
Focus on Software Engineering: Returning Pointers from Functions
494(3)
Focus on Problem Solving and Program Design: A Case Study
497(14)
Serendipity Booksellers Software Development Project---Part 9: A Problem-Solving Exercise
508(3)
Characters and Strings
511(46)
Character Testing
511(5)
Character Case Conversion
516(2)
Review of the Internal Storage of Strings
518(3)
Library Functions for Working with Strings
521(7)
String/Numeric Conversion Functions
528(3)
Focus on Software Engineering: Writing Your Own String-handling Functions
531(6)
Focus on Problem Solving and Program Design: A Business Case Study
537(20)
Serendipity Booksellers Software Development Project---Part 10: A Problem-Solving Exercise
554(3)
Structured Data
557(72)
Abstract Data Types
557(2)
Focus on Software Engineering: Combining Data into Structures
559(4)
Accessing Structure Members
563(4)
Initializing a Structure
567(4)
Arrays of Structures
571(3)
Focus on Software Engineering: Nested Structures
574(4)
Structures as Function Arguments
578(4)
Returning a Structure from a Function
582(3)
Pointers to Structures
585(4)
Focus on Software Engineering: When to Use., When to Use - >, and When to Use*
589(2)
Unions
591(4)
Focus on Problem Solving and Program Design: A Case Study
595(34)
Serendipity Booksellers Software Development Project---Part 11: A Problem-Solving Exercise
626(3)
File Operations
629(78)
What is a File?
629(1)
File Names
630(1)
Focus on Software Engineering: The Process of Using a File
631(1)
Setting Up a Program for File Input/Output
632(1)
Opening a File
633(5)
Closing a File
638(2)
Using << to Write Information to a File
640(3)
File Output Formatting
643(3)
Using >> to Read Information from a File
646(1)
Detecting the End of a File
647(2)
Passing File Stream Objects to Functions
649(2)
More Detailed Error Testing
651(3)
Member Functions for Reading and Writing Files
654(7)
Focus on Software Engineering: Working with Multiple Files
661(2)
Binary Files
663(2)
Creating Records with Structures
665(5)
Random Access Files
670(6)
Opening a File for Both Input and Output
676(4)
Focus on Problem Solving and Program Design: A Case Study
680(27)
Serendipity Booksellers Software Development Project---Part 12: A Problem-Solving Exercise
704(3)
Introduction to Classes
707(62)
Procedural and Object-Oriented Programming
707(4)
How are Objects Used?
711(1)
Introduction to the Class
712(3)
Defining Member Functions
715(1)
Defining an Instance of a Class
716(4)
Why Have Private Members?
720(1)
Focus on Software Engineering: Some Design Considerations
721(3)
Focus on Software Engineering: Using Private Member Functions
724(2)
Inline Member Functions
726(3)
Constructors
729(3)
Destructors
732(2)
Constructors that Accept Arguments
734(5)
Focus on Software Engineering: Input Validation Objects
739(3)
Overloaded Constructors
742(2)
Only One Default Constructor and One Destructor
744(1)
Arrays of Objects
745(5)
Focus on Problem Solving and Program Design: An OOP Case Study
750(7)
Focus on Engineering: Object-Oriented Analysis
757(12)
Serendipity Booksellers Software Development Project---Part 13: A Problem-Solving Exercise
767(2)
More About Classes
769(80)
Static Members
769(7)
Friends of Classes
776(5)
Memberwise Assignment
781(2)
Copy Constructors
783(4)
Operator Overloading
787(34)
Object Conversion
821(5)
Creating a String Class
826(11)
Object Composition
837(12)
Serendipity Booksellers Software Development Project---Part 14: A Problem-Solving Exercise
847(2)
Inheritance and Polymorphism
849(52)
What is Inheritance?
849(7)
Protected Members and Class Access
856(6)
Constructors and Destructors
862(6)
Overriding Base Class Functions
868(5)
Polymorphism and Virtual Member Functions
873(5)
Base Class Pointers
878(3)
Classes Derived from Derived Classes
881(3)
Multiple Inheritance
884(17)
Serendipity Booksellers Software Development Project---Part 15: A Problem-Solving Exercise
899(2)
Exceptions, Templates, and the Standard Template Library (STL)
901(42)
Exceptions
901(12)
Function Templates
913(6)
Focus on Software Engineering: Where to Start when Defining Templates
919(1)
Class Templates
920(9)
Introduction to the Standard Template Library (STL)
929(14)
Serendipity Booksellers Software Development Project---Part 16: A Problem-Solving Exercise
942(1)
Linked Lists
943(36)
Introduction to the Linked List ADT
943(2)
Linked List Operations
945(20)
A Linked List Template
965(5)
Variations of the Linked List
970(1)
The STL list Container
970(9)
Serendipity Booksellers Software Development Project---Part 17: A Problem-Solving Exercise
977(2)
Stacks and Queues
979(36)
Introduction to the Stack ADT
979(10)
Dynamic Stacks
989(4)
The STL stack Container
993(2)
Introduction to the Queue ADT
995(7)
Dynamic Queues
1002(4)
The STL deque and queue Containers
1006(9)
Serendipity Booksellers Software Development Project---Part 18: A Problem-Solving Exercise
1013(2)
Recursion
1015(20)
Introduction to Recursion
1015(6)
Focus on Problem Solving and Program Design: The Recursive Factorial Function
1021(2)
Focus on Problem Solving and Program Design: The Recursive GCD Function
1023(1)
Focus on Problem Solving and Program Design: Printing Linked List Nodes in Reverse Order
1024(3)
Focus on Problem Solving and Program Design: The QuickSort Algorithm
1027(4)
Focus on Software Engineering: Recursion Versus Interation
1031(4)
Serendipity Booksellers Software Development Project---Part 19: A Problem-Solving Exercise
1034(1)
Binary Trees
1035(26)
Definition and Applications of Binary Trees
1035(3)
Binary Search Tree Operations
1038(18)
Template Considerations for Binary Trees
1056(5)

Related Products


  • Standard Version of Starting Out With C++
    Standard Version of Starting O...
  • Starting Out with C++ Alternate Package
    Starting Out with C++ Alternat...
  • Starting Out with C++, Standard Version 2005 Update Package
    Starting Out with C++, Standar...


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