Amazon no longer offers textbook rentals. We do!

Sams Teach Yourself C++ in 24 Hours : Complete Starter Kit

by: Liberty, Jesse; Horvath, David B.

Sams Teach Yourself C++ in 24 Hours : Complete Starter Kit

by: Liberty, Jesse; Horvath, David B.

ISBN 13:
9780672326813
ISBN 10:
0672326817
Edition: 4th
Format: Paperback
Copyright: 08/11/2004
Publisher: Sams Publishing
Newer Edition

Rent

Sorry, this item is currently unavailable.

Note: Supplemental materials are not guaranteed with Rental or Used book purchases.

Extend or Purchase Your Rental at Any Time

Need to keep your rental past your due date? At any time before your due date you can extend or purchase your rental through your account.

Summary

Unbeatable formula for learning C++: Easy-to-understand chapters, well-crafted examples, and a C++ compiler to test the examples.

Introduction

(1)

Who Should Read This Book?

(1)

Should I Learn C First?

(1)

Why Should I Learn C++?

(1)

Conventions Used in This Book

(1)

What's on the Companion CD-ROM

(2)

Part I: Introducing C++

Hour 1: Getting Started

(16)

Preparing to Program

(1)

Clearing Up Some Areas of Confusion with C++, ANSI C++, ISO C++, and Windows

(1)

Installing and Setting Up the Compiler

(5)

Installing from CD

(1)

Configuration of the Borland C++BuilderX Compiler

(2)

Compiling with the Borland C++BuilderX Compiler

(1)

Your Compiler and Editor

(1)

Compiling and Linking the Source Code

(1)

Compiling in an Integrated Development Environment

(1)

Linking Your Program

(1)

The Development Cycle

(2)

HELLO.CPP---Your First C++ Program

(2)

Compile Errors

(1)

Q&A

(1)

Workshop

(3)

Quiz

(1)

Exercises

(1)

Quiz Answers

(2)

Hour 2: The Parts of a C++ Program

(14)

Why C++ Is the Right Choice

(4)

Procedural, Structured, and Object-Oriented Programming

(2)

C++ and Object-Oriented Programming

(1)

The Parts of a Simple Program

(3)

Examining the #include, Character by Character

(1)

Line-by-Line Analysis

(2)

Comments

(1)

Types of Comments

(1)

Using Comments in a Simple Sample Program

(1)

Functions

(3)

Calling Functions

(1)

Using Functions

(1)

Using Parameters with Functions

(1)

Q&A

(1)

Workshop

(2)

Quiz

(1)

Exercises

(1)

Quiz Answers

(1)

Hour 3: Variables and Constants

(16)

What Is a Variable?

(4)

Setting Aside Memory

(1)

Size of Integers

(1)

signed and unsigned

(1)

Fundamental Variable Types

(1)

Defining a Variable

(2)

Case Sensitivity

(1)

Keywords

(1)

Creating More Than One Variable at a Time

(1)

Assigning Values to Your Variables

(2)

typedef

(1)

When to Use short and When to Use long

(2)

Wrapping Around in unsigned Integers

(1)

Wrapping Around a signed Integer

(1)

Constants

(2)

Literal Constants

(1)

Symbolic Constants

(1)

Enumerated Constants

(1)

Q&A

(1)

Workshop

(1)

Quiz

(1)

Exercises

(1)

Quiz Answers

(1)

Hour 4: Expressions and Statements

(24)

Statements

(2)

Whitespace

(1)

Compound Statements

(1)

Expressions

(1)

Operators

(6)

Assignment Operator

(1)

Mathematical Operators

(1)

Combining the Assignment and Mathematical Operators

(1)

Increment and Decrement Operators

(1)

Prefix and Postfix Positioned Operators

(2)

Precedence: the Order of Operations

(1)

Nesting Parentheses for Complex Expressions

(2)

Relational Operators

(1)

The if Statement

(6)

The else Clause

(1)

Advanced if Statements

(2)

Use Braces in Nested if Statements

(2)

More About Logical Operators

(3)

Logical AND

(1)

Logical OR

(1)

Logical NOT

(1)

Relational Precedence

(1)

More About Truth and Falsehood

(1)

Q&A

(1)

Workshop

(3)

Quiz

(1)

Exercises

(1)

Quiz Answers

(2)

Hour 5: Functions

(24)

What Is a Function?

(1)

Declaring and Defining Functions

(4)

Declaring the Function

(2)

Defining the Function

(1)

Function Definitions Wrap-Up

(1)

Using Variables with Functions

(3)

Local Variables

(3)

Global Variables

(1)

Function Arguments

(3)

Calling Functions as Parameters

(1)

Parameters Are Also Local Variables

(2)

Returning Values from Functions

(2)

Default Parameters in Functions

(2)

Overloading Functions

(5)

Inline Functions

(2)

The Stack and Functions

(2)

Q&A

(1)

Workshop

(3)

Quiz

(1)

Exercises

(1)

Quiz Answers

(2)

Hour 6: Program Flow

(20)

Looping

(1)

The Roots of Looping goto

(1)

Why goto Isn't Used

(1)

while Loops

100

(8)

More Complicated while Statements

101

(1)

continue and break

102

(2)

while(1) Loops

104

(2)

do. . .while Loops

106

(2)

for Loops

108

(1)

Initialization, Test, and Increment

109

(6)

Advanced for Loops

110

(2)

Empty for Loops

112

(1)

Nested Loops

113

(2)

switch Statements

115

(2)

Q&A

117

(1)

Workshop

117

(2)

Quiz

117

(1)

Exercises

117

(1)

Quiz Answers

118

(1)

Part II: Classes

Hour 7: Basic Classes

119

(16)

What Is a Type?

119

(1)

Creating New Types

120

(1)

Classes and Members

120

(3)

Declaring a Class

121

(1)

Class Naming Conventions

122

(1)

Defining an Object

122

(1)

Classes Versus Objects

123

(1)

Accessing Class Members

123

(1)

Private Versus Public Access

124

(2)

Implementing Class Methods

126

(2)

Constructors and Destructors, or, Creating and Deleting Objects

128

(4)

Default Constructors

129

(1)

Constructors Provided by the Compiler

129

(3)

Q&A

132

(1)

Workshop

132

(3)

Quiz

132

(1)

Exercises

133

(1)

Quiz Answers

133

(2)

Hour 8: More About Classes

135

(12)

const Member Functions

135

(1)

Interface Versus Implementation

136

(1)

Where to Put Class Declarations and Method Definitions

137

(1)

Inline Implementation

138

(2)

Classes with Other Classes as Member Data

140

(5)

Q&A

145

(1)

Workshop

146

(1)

Quiz

146

(1)

Exercises

146

(1)

Quiz Answers

146

(1)

Part III: Memory Management

Hour 9: Pointers

147

(18)

Understanding Pointers and Their Usage

147

(10)

Storing the Address in a Pointer

150

(2)

Pointer Names

152

(1)

The Indirection Operator, or Using Pointers Indirectly

152

(1)

Pointers, Addresses, and Variables

153

(1)

Manipulating Data by Using Pointers

153

(2)

Examining Addresses Stored in Pointers

155

(2)

Why Would You Use Pointers?

157

(1)

The Stack and the Heap

157

(6)

Using the new Keyword

159

(1)

Using the delete Keyword

160

(2)

Avoiding Memory Leaks

162

(1)

Q&A

163

(1)

Workshop

163

(2)

Quiz

163

(1)

Exercises

163

(1)

Quiz Answers

164

(1)

Hour 10: Advanced Pointers

165

(12)

Creating Objects on the Heap

165

(1)

Deleting Objects

165

(2)

Accessing Data Members Using Pointers

167

(1)

Member Data on the Heap

168

(1)

The this Pointer

169

(2)

Stray or Dangling Pointers

171

(1)

const Pointers

172

(2)

const Pointers and const Member Functions

172

(2)

const this Pointers

174

(1)

Q&A

174

(1)

Workshop

175

(2)

Quiz

175

(1)

Exercises

175

(1)

Quiz Answers

175

(2)

Hour 11: References

177

(16)

What Is a Reference?

177

(1)

Creating a Reference

178

(1)

Using the Address of Operator on References

179

(3)

What Can Be Referenced?

182

(1)

Null Pointers and Null References

183

(1)

Passing Function Arguments by Reference

183

(4)

Making swap() Work with Pointers

184

(2)

Implementing swap () with References

186

(1)

Understanding Function Headers and Prototypes

187

(1)

Returning Multiple Values

188

(3)

Returning Values by Reference

190

(1)

Q&A

191

(1)

Workshop

191

(2)

Quiz

191

(1)

Exercises

192

(1)

Quiz Answers

192

(1)

Hour 12: Advanced References and Pointers

193

(16)

Passing by Reference for Efficiency

193

(3)

Passing a const Pointer

196

(2)

References as an Alternative to Pointers

198

(2)

When to Use References and When to Use Pointers

200

(1)

Don't Return a Reference to an Object That Isn't in Scope!

201

(1)

Returning a Reference to an Object on the Heap

202

(3)

Pointer, Pointer, Who Has the Pointer?

205

(1)

Q&A

205

(1)

Workshop

206

(3)

Quiz

206

(1)

Exercises

206

(1)

Quiz Answers

207

(2)

Part IV: Power Tools

Hour 13: Advanced Functions

209

(12)

Overloaded Member Functions

209

(2)

Using Default Values

211

(2)

Choosing Between Default Values and Overloaded Functions

213

(1)

Overloading Constructors

213

(1)

Initializing Objects

214

(1)

The Copy Constructor

214

(5)

Q&A

219

(1)

Workshop

219

(2)

Quiz

219

(1)

Exercises

220

(1)

Quiz Answers

220

(1)

Hour 14: Operator Overloading

221

(18)

How to Overload Operators

221

(11)

Writing an Increment Function

222

(2)

Overloading the Postfix Operator

224

(1)

The Difference Between Prefix and Postfix

224

(2)

operator+

226

(1)

Overloading operator+

227

(2)

Limitations on Operator Overloading

229

(1)

What to Overload

229

(1)

operator=

229

(3)

Conversion Operators

232

(3)

The int() Operator

234

(1)

Q&A

235

(1)

Workshop

236

(3)

Quiz

236

(1)

Exercises

236

(1)

Quiz Answers

237

(2)

Hour 15: Arrays

239

(22)

What Is an Array?

239

(1)

Array Elements

240

(1)

Writing Past the End of an Array

241

(1)

Fence Post Errors

242

(1)

Initializing Arrays

242

(1)

Arrays of Objects

243

(2)

Multidimensional Arrays

245

(3)

Initializing Multidimensional Arrays

246

(2)

A Word About Memory

248

(1)

Arrays of Pointers

248

(2)

Declaring Arrays on the Heap

250

(1)

A Pointer to an Array Versus an Array of Pointers

250

(1)

Pointers and Array Names

251

(2)

Deleting Arrays on the Heap

253

(1)

char Arrays

254

(2)

strcpy() and strncpy()

256

(1)

String Classes

257

(1)

Q&A

258

(1)

Workshop

258

(3)

Quiz

258

(1)

Exercises

258

(1)

Quiz Answers

259

(2)

Part V: Inheritance and Polymorphism

Hour 16: Inheritance

261

(20)

What Is Inheritance?

261

(4)

Inheritance and Derivation

262

(1)

Using the Animal Kingdom to Explain Inheritance

263

(1)

The Syntax of Derivation

264

(1)

Private Versus Protected

265

(2)

Constructors and Destructors

267

(2)

Passing Arguments to Base Constructors

269

(5)

Overriding Functions

274

(5)

Overloading Versus Overriding

276

(1)

Hiding the Base Class Method

276

(2)

Calling the Base Method

278

(1)

Q&A

279

(1)

Workshop

279

(2)

Quiz

280

(1)

Exercises

280

(1)

Quiz Answers

280

(1)

Hour 17: Polymorphism and Derived Classes

281

(14)

Polymorphism Implemented with Virtual Methods

281

(12)

How Virtual Member Functions Work

285

(1)

You Can't Get There from Here

286

(1)

Slicing

287

(2)

Virtual Destructors

289

(1)

Virtual Copy Constructors

289

(3)

The Cost of Virtual Methods

292

(1)

Q&A

293

(1)

Workshop

293

(2)

Quiz

294

(1)

Exercises

294

(1)

Quiz Answers

294

(1)

Hour 18: Advanced Polymorphism

295

(22)

Problems with Single Inheritance

295

(4)

Abstract Data Types

299

(14)

Pure Virtual Functions

302

(4)

Implementing Pure Virtual Functions

306

(3)

Complex Hierarchies of Abstraction

309

(4)

Which Types Are Abstract?

313

(1)

Q&A

313

(1)

Workshop

314

(3)

Quiz

314

(1)

Exercises

315

(1)

Quiz Answers

315

(2)

Hour 19: Linked Lists

317

(14)

Linked Lists and Other Structures

317

(1)

A Case Study in Using Linked Lists

318

(9)

Delegation of Responsibility

319

(1)

The Component Parts

319

(8)

What You Have Learned About Linked Lists

327

(2)

Q&A

329

(1)

Workshop

329

(2)

Quiz

329

(1)

Exercises

329

(1)

Quiz Answers

330

(1)

Part VI: Special Topics

Hour 20: Special Classes, Functions, and Pointers

331

(30)

Static Member Data

331

(3)

Static Member Functions

334

(1)

Containment of Classes

335

(7)

Accessing Members of the Contained Class

341

(1)

Filtering Access to Contained Members

341

(1)

The Cost of Containment

341

(1)

Copying by Value Versus by Reference

342

(1)

Friend Classes

342

(1)

Friend Functions

343

(1)

Pointers to Functions

343

(15)

Shorthand Invocation

346

(1)

Arrays of Pointers to Functions

346

(2)

Passing Pointers to Functions to Other Functions

348

(3)

Using typedef with Pointers to Functions

351

(2)

Pointers to Member Functions

353

(3)

Arrays of Pointers to Member Functions

356

(2)

Q&A

358

(1)

Workshop

359

(2)

Quiz

359

(1)

Exercises

359

(1)

Quiz Answers

360

(1)

Hour 21: The Preprocessor

361

(28)

The Preprocessor and the Compiler

361

(1)

Seeing the Intermediate Form

361

(1)

Using the #define Directive

362

(2)

Using #define for Constants

362

(1)

Using #define and #ifdef for Tests

362

(1)

The #else Precompiler Command

363

(1)

Inclusion and Inclusion Guards

364

(2)

Defining on the Command Line

365

(1)

Undefining

366

(1)

Conditional Compilation

366

(1)

Macro Functions

366

(3)

Why All the Parentheses?

367

(2)

Macros Versus Functions and Templates

369

(1)

String Manipulation

369

(2)

Stringizing Operator

369

(1)

Concatenation Operator

370

(1)

Predefined Macros

371

(15)

assert() Predefined Macro

371

(15)

Q&A

386

(1)

Workshop

386

(3)

Quiz

386

(1)

Exercises

386

(1)

Quiz Answers

387

(2)

Hour 22: Object-Oriented Analysis and Design

389

(28)

The Development Cycle

389

(1)

Simulating an Alarm System

390

(6)

Conceptualization

391

(1)

Analysis and Requirements

391

(1)

High-Level and Low-Level Design

391

(1)

Other Objects

392

(1)

What Are the Classes?

393

(1)

How Are Alarms Reported?

394

(1)

Event Loops

394

(2)

PostMaster: A Case Study

396

(19)

Measure Twice, Cut Once

397

(1)

Divide and Conquer

398

(1)

Message Format

399

(1)

Initial Class Design

399

(1)

Rooted Hierarchies Versus Non-Rooted

400

(2)

Designing the Interfaces

402

(2)

Building a Prototype

404

(1)

The 80/80 Rule

405

(1)

Designing the PostMasterMessage Class

405

(1)

The Application Programming Interface

406

(1)

Programming in Large Groups

407

(1)

Ongoing Design Considerations

407

(2)

Working with Driver Programs

409

(6)

Q&A

415

(1)

Workshop

416

(1)

Quiz

416

(1)

Exercises

416

(1)

Quiz Answers

416

(1)

Hour 23: Templates

417

(18)

What Are Templates?

417

(1)

Instances of the Template

418

(1)

Template Definition

418

(7)

Using Template Items

425

(6)

The Standard Template Library

431

(1)

Q&A

432

(1)

Workshop

432

(3)

Quiz

432

(1)

Exercises

433

(1)

Quiz Answers

433

(2)

Hour 24: Exceptions, Error Handling, and More

435

(22)

Bugs, Errors, Mistakes, and Code Rot

435

(2)

Handling the Unexpected

437

(1)

Exceptions

437

(5)

How Exceptions Are Used

438

(4)

Using try Blocks and catch Blocks

442

(6)

Catching Exceptions

442

(1)

More Than One catch Specification

443

(1)

Catching by Reference and Polymorphism

444

(4)

Writing Professional-Quality Code

448

(5)

Braces

448

(1)

Long Lines

449

(1)

switch Statements

449

(1)

Program Text

450

(1)

Identifier Names

450

(1)

Spelling and Capitalization of Names

451

(1)

Comments

451

(1)

Access

452

(1)

Class Definitions

453

(1)

include Files

453

(1)

assert()

453

(1)

const

453

(1)

Additional Resources

453

(2)

Where to Get Help and Advice

454

(1)

Amazon no longer offers textbook rentals. We do!

Sams Teach Yourself C++ in 24 Hours : Complete Starter Kit

Sams Teach Yourself C++ in 24 Hours : Complete Starter Kit

9780672326813

0672326817

Summary

Author Biography

Table of Contents

Supplemental Materials

Write a Review

Amazon no longer offers textbook rentals. We do!

Sams Teach Yourself C++ in 24 Hours : Complete Starter Kit

Sams Teach Yourself C++ in 24 Hours : Complete Starter Kit

9780672326813

0672326817

Summary

Author Biography

Table of Contents

Supplemental Materials

Write a Review

Related Products