Amazon no longer offers textbook rentals. We do!

Sams Teach Yourself C++ in 21 Days

by: Liberty, Jesse; Jones, Bradley L.

Sams Teach Yourself C++ in 21 Days

by: Liberty, Jesse; Jones, Bradley L.

ISBN 13:
9780672327117
ISBN 10:
0672327112
Edition: 5th
Format: Paperback
Copyright: 01/01/2005
Publisher: Sams
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

Explains the fundamentals of C++ and how to use it to build object-oriented programs, add functionality, debug programs, learn exception and errorhandling techniques, and make code ANSI compliant.

Introduction

(1)

Who Should Read This Book

(1)

Conventions Used in This Book

(1)

Sample Code for This Book

(1)

Week 1 At a Glance

(216)

A Note to C Programmers

(1)

Where You Are Going

(2)

Getting Started

(20)

A Brief History of C++

(6)

The Need for Solving Problems

(1)

Procedural, Structured, and Object-Oriented Programming

(1)

Object-Oriented Programming (OOP)

(1)

C++ and Object-Oriented Programming

(2)

How C++ Evolved

(1)

Should I Learn C First?

(1)

C++, Java, and C#

(1)

Microsoft's Managed Extensions to C++

(1)

The ANSI Standard

(1)

Preparing to Program

(1)

Your Development Environment

(1)

The Process of Creating the Program

(1)

Creating an Object File with the Compiler

(1)

Creating an Executable File with the Linker

(1)

The Development Cycle

(2)

Hello.cpp---Your First C++ Program

(2)

Getting Started with Your Compiler

(1)

Building the Hello World Project

(1)

Compile Errors

(1)

Summary

(1)

Q&A

(1)

Workshop

(3)

Quiz

(1)

Exercises

(2)

The Anatomy of a C++ Program

(16)

A Simple Program

(3)

A Brief Look at cout

(2)

Using the Standard Namespace

(2)

Commenting Your Programs

(3)

Types of Comments

(1)

Using Comments

(1)

A Final Word of Caution About Comments

(1)

Functions

(3)

Using Functions

(2)

Methods Versus Functions

(1)

Summary

(1)

Q&A

(1)

Workshop

(2)

Quiz

(1)

Exercises

(2)

Working with Variables and Constants

(26)

What Is a Variable?

(6)

Storing Data in Memory

(1)

Setting Aside Memory

(1)

Size of Integers

(2)

signed and unsigned

(1)

Fundamental Variable Types

(2)

Defining a Variable

(3)

Case Sensitivity

(1)

Naming Conventions

(1)

Keywords

(1)

Creating More Than One Variable at a Time

(1)

Assigning Values to Your Variables

(2)

Creating Aliases with typedef

(1)

When to Use short and When to Use long

(3)

Wrapping Around an unsigned Integer

(1)

Wrapping Around a signed Integer

(1)

Working with Characters

(3)

Characters and Numbers

(1)

Special Printing Characters

(1)

Constants

(2)

Literal Constants

(1)

Symbolic Constants

(2)

Enumerated Constants

(2)

Summary

(1)

Q&A

(1)

Workshop

(2)

Quiz

(1)

Exercises

(1)

Creating Expressions and Statements

(32)

Starting with Statements

(1)

Using Whitespace

(1)

Blocks and Compound Statements

(1)

Expressions

(1)

Working with Operators

(3)

Assignment Operators

(1)

Mathematical Operators

(2)

Combining the Assignment and Mathematical Operators

(1)

Incrementing and Decrementing

(3)

Prefixing Versus Postfixing

(2)

Understanding Operator Precedence

(1)

Nesting Parentheses

(1)

The Nature of Truth

(1)

Evaluating with the Relational Operators

(1)

The if Statement

(8)

Indentation Styles

(1)

The else Statement

(2)

Advanced if Statements

(2)

Using Braces in Nested if Statements

(3)

Using the Logical Operators

(1)

The Logical and Operator

(1)

The Logical or Operator

(1)

The Logical not Operator

(1)

Short Circuit Evaluation

(1)

Relational Precedence

(1)

More About Truth and Falsehood

(1)

The Conditional (Ternary) Operator

(1)

Summary

(1)

Q&A

(1)

Workshop

(3)

Quiz

(1)

Exercises

(2)

Organizing into Functions

(38)

What Is a Function?

100

(1)

Return Values, Parameters, and Arguments

100

(1)

Declaring and Defining Functions

101

(4)

Function Prototypes

102

(1)

Defining the Function

103

(2)

Execution of Functions

105

(1)

Determining Variable Scope

105

(4)

Local Variables

105

(2)

Local Variables Within Blocks

107

(2)

Parameters Are Local Variables

109

(3)

Global Variables

110

(2)

Global Variables: A Word of Caution

112

(1)

Considerations for Creating Function Statements

112

(1)

More About Function Arguments

113

(1)

More About Return Values

114

(2)

Default Parameters

116

(2)

Overloading Functions

118

(3)

Special Topics About Functions

121

(8)

Inline Functions

122

(2)

Recursion

124

(5)

How Functions Work---A Peek Under the Hood

129

(4)

Levels of Abstraction

129

(4)

Summary

133

(1)

Q&A

134

(1)

Workshop

134

(3)

Quiz

135

(1)

Exercises

135

(2)

Understanding Object-Oriented Programming

137

(38)

Is C++ Object-Oriented?

137

(2)

Creating New Types

139

(1)

Introducing Classes and Members

140

(2)

Declaring a Class

141

(1)

A Word on Naming Conventions

141

(1)

Defining an Object

142

(1)

Classes Versus Objects

142

(1)

Accessing Class Members

142

(2)

Assigning to Objects, Not to Classes

143

(1)

If You Don't Declare It, Your Class Won't Have It

143

(1)

Private Versus Public Access

144

(6)

Making Member Data Private

146

(4)

Implementing Class Methods

150

(3)

Adding Constructors and Destructors

153

(4)

Getting a Default Constructor and Destructor

153

(1)

Using the Default Constructor

154

(3)

Including const Member Functions

157

(1)

Interface Versus Implementation

158

(3)

Where to Put Class Declarations and Method Definitions

161

(1)

Inline Implementation

162

(3)

Classes with Other Classes as Member Data

165

(4)

Exploring Structures

169

(1)

Summary

170

(1)

Q&A

171

(1)

Workshop

172

(3)

Quiz

172

(1)

Exercises

173

(2)

More on Program Flow

175

(44)

Looping

175

(2)

The Roots of Looping: goto

176

(1)

Why goto Is Shunned

176

(1)

Using while Loops

177

(7)

Exploring More Complicated while Statements

179

(1)

Introducing continue and break

180

(3)

Examining while (true) Loops

183

(1)

Implementing do. . .while Loops

184

(2)

Using do. . .while

186

(1)

Looping with the for Statement

187

(9)

Advanced for Loops

190

(2)

Empty for Loops

192

(1)

Nesting Loops

193

(2)

Scoping in for Loops

195

(1)

Summing Up Loops

196

(2)

Controlling Flow with switch Statements

198

(7)

Using a switch Statement with a Menu

201

(4)

Summary

205

(1)

Q&A

205

(1)

Workshop

206

(3)

Quiz

206

(1)

Exercises

206

(3)

In Review

209

(10)

Week 2 At a Glance

219

(284)

Where You Are Going

219

(2)

Understanding Pointers

221

(34)

What Is a Pointer?

222

(10)

A Bit About Memory

222

(1)

Getting a Variable's Memory Address

222

(2)

Storing a Variable's Address in a Pointer

224

(1)

Pointer Names

224

(1)

Getting the Value from a Variable

225

(1)

Dereferencing with the Indirection Operator

226

(1)

Pointers, Addresses, and Variables

227

(1)

Manipulating Data by Using Pointers

228

(1)

Examining the Address

229

(3)

Why Would You Use Pointers?

232

(1)

The Stack and the Free Store (Heap)

232

(5)

Allocating Space with the new Keyword

234

(1)

Putting Memory Back: The delete Keyword

235

(2)

Another Look at Memory Leaks

237

(1)

Creating Objects on the Free Store

238

(1)

Deleting Objects from the Free Store

238

(1)

Accessing Data Members

239

(2)

Creating Member Data on the Free Store

241

(2)

The this Pointer

243

(2)

Stray, Wild, or Dangling Pointers

245

(3)

Using const Pointers

248

(3)

const Pointers and const Member Functions

249

(2)

Using a const this Pointers

251

(1)

Summary

251

(1)

Q&A

252

(1)

Workshop

252

(3)

Quiz

252

(1)

Exercises

253

(2)

Exploiting References

255

(34)

What Is a Reference?

255

(2)

Using the Address-Of Operator (&) on References

257

(3)

Attempting to Reassign References (Not!)

259

(1)

Referencing Objects

260

(2)

Null Pointers and Null References

262

(1)

Passing Function Arguments by Reference

262

(5)

Making swap() Work with Pointers

264

(1)

Implementing swap () with References

265

(2)

Understanding Function Headers and Prototypes

267

(1)

Returning Multiple Values

268

(3)

Returning Values by Reference

270

(1)

Passing by Reference for Efficiency

271

(8)

Passing a const Pointer

274

(3)

References as an Alternative

277

(2)

Knowing When to Use References Versus Pointers

279

(1)

Mixing References and Pointers

280

(1)

Returning Out-of-Scope Object References

281

(4)

Returning a Reference to an Object on the Heap

283

(2)

Pointer, Pointer, Who Has the Pointer?

285

(1)

Summary

286

(1)

Q&A

286

(1)

Workshop

287

(2)

Quiz

287

(1)

Exercises

287

(2)

Working with Advanced Functions

289

(40)

Overloaded Member Functions

289

(3)

Using Default Values

292

(2)

Choosing Between Default Values and Overloaded Functions

294

(1)

The Default Constructor

294

(1)

Overloading Constructors

295

(2)

Initializing Objects

297

(1)

The Copy Constructor

298

(4)

Operator Overloading

302

(18)

Writing an Increment Function

303

(1)

Overloading the Prefix Operator

304

(2)

Returning Types in Overloaded Operator Functions

306

(1)

Returning Nameless Temporaries

307

(2)

Using the this Pointer

309

(2)

Overloading the Postfix Operator

311

(1)

Difference Between Prefix and Postfix

311

(2)

Overloading Binary Mathematical Operators

313

(3)

Issues in Operator Overloading

316

(1)

Limitations on Operator Overloading

316

(1)

What to Overload

317

(1)

The Assignment Operator

317

(3)

Handling Data Type Conversion

320

(3)

Conversion Operators

323

(2)

Summary

325

(1)

Q&A

325

(1)

Workshop

326

(3)

Quiz

326

(1)

Exercises

327

(2)

Object-Oriented Analysis and Design

329

(42)

Building Models

329

(1)

Software Design: The Modeling Language

330

(1)

Software Design: The Process

331

(4)

Waterfall Versus Iterative Development

332

(1)

The Process of Iterative Development

333

(2)

Step 1: The Conceptualization Phase: Starting with The Vision

335

(1)

Step 2: The Analysis Phase: Gathering Requirements

336

(14)

Use Cases

336

(11)

Application Analysis

347

(1)

Systems Analysis

347

(1)

Planning Documents

348

(1)

Visualizations

349

(1)

Artifacts

349

(1)

Step 3: The Design Phase

350

(16)

What Are the Classes?

350

(2)

Transformations

352

(1)

Other Transformations

353

(1)

Building the Static Model

354

(9)

Dynamic Model

363

(3)

Steps 4--6: Implementation, Testing, and Rollout?

366

(1)

Iterations

367

(1)

Summary

367

(1)

Q&A

367

(1)

Workshop

368

(3)

Quiz

368

(1)

Exercises

369

(2)

Implementing Inheritance

371

(36)

What Is Inheritance?

371

(5)

Inheritance and Derivation

372

(1)

The Animal Kingdom

373

(1)

The Syntax of Derivation

374

(2)

Private Versus Protected

376

(2)

Inheritance with Constructors and Destructors

378

(7)

Passing Arguments to Base Constructors

381

(4)

Overriding Base Class Functions

385

(6)

Hiding the Base Class Method

387

(2)

Calling the Base Method

389

(2)

Virtual Methods

391

(12)

How Virtual Functions Work

395

(1)

Trying to Access Methods from a Base Class

396

(1)

Slicing

397

(2)

Creating Virtual Destructors

399

(1)

Virtual Copy Constructors

400

(3)

The Cost of Virtual Methods

403

(1)

Summary

403

(1)

Q&A

404

(1)

Workshop

405

(2)

Quiz

405

(1)

Exercises

405

(2)

Managing Arrays and Strings

407

(42)

What Is an Array?

407

(9)

Accessing Array Elements

408

(2)

Writing Past the End of an Array

410

(3)

Fence Post Errors

413

(1)

Initializing Arrays

413

(1)

Declaring Arrays

414

(2)

Using Arrays of Objects

416

(5)

Declaring Multidimensional Arrays

417

(2)

Initializing Multidimensional Arrays

419

(2)

Building Arrays of Pointers

421

(2)

A Look at Pointer Arithmetic---An Advanced Topic

423

(3)

Declaring Arrays on the Free Store

426

(6)

A Pointer to an Array Versus an Array of Pointers

426

(1)

Pointers and Array Names

427

(2)

Deleting Arrays on the Free Store

429

(1)

Resizing Arrays at Runtime

429

(3)

char Arrays and Strings

432

(3)

Using the strcpy ( ) and strncpy ( ) Methods

435

(1)

String Classes

435

(9)

Linked Lists and Other Structures

444

(1)

Creating Array Classes

444

(1)

Summary

445

(1)

Q&A

445

(1)

Workshop

446

(3)

Quiz

446

(1)

Exercises

447

(2)

Polymorphism

449

(54)

Problems with Single Inheritance

449

(7)

Percolating Upward

452

(1)

Casting Down

453

(3)

Adding to Two Lists

456

(1)

Multiple Inheritance

456

(17)

The Parts of a Multiply Inherited Object

460

(1)

Constructors in Multiply Inherited Objects

460

(3)

Ambiguity Resolution

463

(1)

Inheriting from Shared Base Class

464

(4)

Virtual Inheritance

468

(4)

Problems with Multiple Inheritance

472

(1)

Mixins and Capabilities Classes

473

(1)

Abstract Data Types

473

(13)

Pure Virtual Functions

477

(1)

Implementing Pure Virtual Functions

478

(4)

Complex Hierarchies of Abstraction

482

(4)

Which Classes Are Abstract?

486

(1)

Summary

486

(1)

Q&A

487

(1)

Workshop

488

(3)

Quiz

488

(1)

Exercises

489

(2)

In Review

491

(12)

Week 3 At a Glance

503

(304)

Where You Are Going

503

(2)

Special Classes and Functions

505

(32)

Sharing Data Among Objects of the Same Type: Static Member Data

506

(5)

Using Static Member Functions

511

(3)

Pointers to Functions

514

(14)

Why Use Function Pointers?

517

(4)

Arrays of Pointers to Functions

521

(2)

Passing Pointers to Functions to Other Functions

523

(2)

Using typedef with Pointers to Functions

525

(3)

Pointers to Member Functions

528

(5)

Arrays of Pointers to Member Functions

531

(2)

Summary

533

(1)

Q&A

533

(1)

Workshop

534

(3)

Quiz

534

(1)

Exercises

534

(3)

Advanced Inheritance

537

(56)

Aggregation

537

(15)

Accessing Members of the Aggregated Class

545

(1)

Controlling Access to Aggregated Members

545

(1)

Cost of Aggregation

546

(3)

Copying by Value

549

(3)

Implementation in Terms of Inheritance Versus Aggregation Delegation

552

(10)

Using Delegation

553

(9)

Private Inheritance

562

(9)

Adding Friend Classes

571

(9)

Friend Functions

580

(1)

Friend Functions and Operator Overloading

580

(5)

Overloading the Insertion Operator

585

(4)

Summary

589

(1)

Q&A

590

(1)

Workshop

591

(2)

Quiz

591

(1)

Exercises

591

(2)

Working with Streams

593

(44)

Overview of Streams

593

(4)

Encapsulation of Data Flow

594

(1)

Understanding Buffering

594

(3)

Streams and Buffers

597

(1)

Standard I/O Objects

597

(1)

Redirection of the Standard Streams

598

(1)

Input Using cin

599

(5)

Inputting Strings

600

(1)

String Problems

601

(2)

The cin Return Value

603

(1)

Other Member Functions of cin

604

(9)

Single Character Input

604

(3)

Getting Strings from Standard Input

607

(3)

Using cin.ignore( )

610

(1)

Peeking at and Returning Characters: peek ( ) and putback ( )

611

(2)

Outputting with cout

613

(7)

Flushing the Output

613

(1)

Functions for Doing Output

613

(2)

Manipulators, Flags, and Formatting Instructions

615

(5)

Streams Versus the printf ( ) Function

620

(3)

File Input and Output

623

(1)

Using the of stream

624

(5)

Condition States

624

(1)

Opening Files for Input and Output

624

(2)

Changing the Default Behavior of of stream on Open

626

(3)

Binary Versus Text Files

629

(2)

Command-line Processing

631

(3)

Summary

634

(1)

Q&A

635

(1)

Workshop

636

(1)

Quiz

636

(1)

Exercises

636

(1)

Creating and Using Namespaces

637

(22)

Getting Started

637

(1)

Resolving Functions and Classes by Name

638

(5)

Visibility of Variables

640

(1)

Linkage

641

(1)

Static Global Variables

642

(1)

Creating a Namespace

643

(3)

Declaring and Defining Types

644

(1)

Defining Functions Outside a Namespace

645

(1)

Adding New Members

645

(1)

Nesting Namespaces

646

(1)

Using a Namespace

646

(2)

The using Keyword

648

(4)

The using Directive

648

(2)

The using Declaration

650

(2)

The Namespace Alias

652

(1)

The Unnamed Namespace

652

(2)

The Standard Namespace std

654

(1)

Summary

655

(1)

Q&A

656

(1)

Workshop

656

(3)

Quiz

656

(1)

Exercises

657

(2)

Templates

659

(56)

What Are Templates?

659

(2)

Building a Template Definition

661

(8)

Using the Name

664

(1)

Implementing the Template

665

(4)

Passing Instantiated Template Objects to Functions

669

(1)

Templates and Friends

670

(8)

Nontemplate Friend Classes and Functions

670

(4)

General Template Friend Class or Function

674

(4)

Using Template Items

678

(15)

Using Specialized Functions

683

(6)

Static Members and Templates

689

(4)

The Standard Template Library

693

(18)

Using Containers

693

(1)

Understanding Sequence Containers

694

(10)

Understanding Associative Containers

704

(4)

Working with the Algorithm Classes

708

(3)

Summary

711

(1)

Q&A

712

(1)

Workshop

713

(2)

Quiz

713

(1)

Exercises

713

(2)

Handling Errors and Exceptions

715

(36)

Bugs, Errors, Mistakes, and Code Rot

716

(2)

Exceptional Circumstances

717

(1)

The Idea Behind Exceptions

718

(10)

The Parts of Exception Handling

719

(3)

Causing Your Own Exceptions

722

(2)

Creating an Exception Class

724

(4)

Placing try Blocks and catch Blocks

728

(1)

How Catching Exceptions Work

728

(7)

Using More Than One catch Specification

729

(3)

Exception Hierarchies

732

(3)

Data in Exceptions and Naming Exception Objects

735

(7)

Exceptions and Templates

742

(3)

Exceptions Without Errors

745

(1)

A Word About Code Rot

746

(1)

Bugs and Debugging

746

(2)

Breakpoints

747

(1)

Watch Points

747

(1)

Examining Memory

747

(1)

Assembler

747

(1)

Summary

748

(1)

Q&A

748

(1)

Workshop

749

(2)

Quiz

749

(1)

Exercises

750

(1)

What's Next

751

(56)

The Preprocessor and the Compiler

752

(1)

The #define Preprocessor Directive

752

(3)

Using #define for Constants

753

(1)

Using #define for Tests

753

(1)

The #else Precompiler Command

754

(1)

Inclusion and Inclusion Guards

755

(1)

Macro Functions

756

(3)

Why All the Parentheses?

757

(2)

String Manipulation

759

(1)

Stringizing

759

(1)

Concatenation

759

(1)

Predefined Macros

760

(1)

The assert () Macro

761

(10)

Debugging with assert ()

762

(1)

Using assert () Versus Exceptions

763

(1)

Side Effects

763

(1)

Class Invariants

764

(5)

Printing Interim Values

769

(2)

Inline Functions

771

(2)

Bit Twiddling

773

(6)

Operator AND

773

(1)

Operator OR

774

(1)

Operator Exclusive OR

774

(1)

The Complement Operator

774

(1)

Setting Bits

774

(1)

Clearing Bits

774

(1)

Flipping Bits

775

(1)

Bit Fields

775

(4)

Programming Style

779

(5)

Indenting

779

(1)

Braces

779

(1)

Long Lines and Function Length

780

(1)

Structuring switch Statements

780

(1)

Program Text

780

(1)

Naming Identifiers

781

(1)

Spelling and Capitalization of Names

782

(1)

Comments

782

(1)

Setting Up Access

783

(1)

Class Definitions

783

(1)

include Files

784

(1)

Using assert ()

784

(1)

Making Items Constant with const

784

(1)

Next Steps in Your C++ Development

784

(2)

Where to Get Help and Advice

785

(1)

Related C++ Topics: Managed C++, C#, and Microsoft's .NET

785

(1)

Staying in Touch

786

(1)

Summary

786

(1)

Q&A

787

(1)

Workshop

788

(3)

Quiz

788

(1)

Exercises

789

(2)

In Review

791

(16)

A Working with Numbers: Binary and Hexadecimal

807

(10)

Using Other Bases

808

(1)

Converting to Different Bases

809

(4)

Binary

810

(1)

Why Base 2?

811

(1)

Bits, Bytes, and Nybbles

812

(1)

What's a KB?

812

(1)

Binary Numbers

812

(1)

Hexadecimal

813

(4)

B C++ Keywords

817

(2)

C Operator Precedence

819

(2)

D Answers

821

(54)

Day 1

821

(1)

Quiz

821

(1)

Exercises

822

(1)

Day 2

822

(2)

Quiz

822

(1)

Exercises

823

(1)

Day 3

824

(1)

Quiz

824

(1)

Exercises

825

(1)

Day 4

825

(1)

Quiz

825

(1)

Exercises

826

(1)

Day 5

826

(3)

Quiz

826

(1)

Exercises

827

(2)

Day 6

829

(3)

Quiz

829

(1)

Exercises

829

(3)

Day 7

832

(1)

Quiz

832

(1)

Exercises

832

(1)

Day 8

833

(2)

Quiz

833

(1)

Exercises

834

(1)

Day 9

835

(2)

Quiz

835

(1)

Exercises

835

(2)

Day 10

837

(5)

Quiz

837

(1)

Exercises

838

(4)

Day 11

842

(4)

Quiz

842

(1)

Exercises

842

(4)

Day 12

846

(1)

Quiz

846

(1)

Exercises

846

(1)

Day 13

847

(1)

Quiz

847

(1)

Exercises

847

(1)

Day 14

848

(2)

Quiz

848

(1)

Exercises

849

(1)

Day 15

850

(6)

Quiz

850

(1)

Exercises

850

(6)

Day 16

856

(3)

Quiz

856

(1)

Exercises

856

(3)

Day 17

859

(3)

Quiz

859

(1)

Exercises

860

(2)

Day 18

862

(1)

Quiz

862

(1)

Exercises

863

(1)

Day 19

863

(4)

Quiz

863

(1)

Exercises

864

(3)

Day 20

867

(6)

Quiz

867

(1)

Exercises

868

(5)

Day 21

873

(2)

Quiz

873

(1)

Exercises

874

(1)

E A Look at Linked Lists

875

(12)

The Component Parts of Your Linked List

876

(11)

Index

887

Amazon no longer offers textbook rentals. We do!

Sams Teach Yourself C++ in 21 Days

Sams Teach Yourself C++ in 21 Days

9780672327117

0672327112

Summary

Table of Contents

Supplemental Materials

Write a Review

Amazon no longer offers textbook rentals. We do!

Sams Teach Yourself C++ in 21 Days

Sams Teach Yourself C++ in 21 Days

9780672327117

0672327112

Summary

Table of Contents

Supplemental Materials

Write a Review

Related Products