C++ Without Fear : A Beginner's Guide That Makes You Feel Smart

, by Overland, Brian

Write a Review

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

ISBN: 9780321246950 | 0321246950
Cover: Paperback w/CD
Copyright: 1/1/2005

Sorry, this item is currently not available.

Summary

Author Biography

Supplemental Materials

An experienced and highly regarded programming author makes C++ easy to learn - and fun - for complete novices.

Preface

xix

Why a New C++ Book?

xix

What Else Is New about This Book?

Multiple Learning Paths: What Fits You Best

What If You Already Have a Programming Background?

xxi

What Is Not Covered?

xxi

Why Should Anyone Start with C++?

xxii

To Get Started . . .

xxiii

Tips and Tricks: What Do I Watch Out For?

xxiii

Acknowledgments

xxv

Your First C++ Programs

(32)

Thinking like a Programmer

(5)

Computers Do Only What You Tell Them

(1)

Determine What the Program Will Do

(1)

Write the Equivalent C++ Statements

(2)

Some Nerdy Definitions---A Review

(2)

What's Different about C++?

(2)

Interlude What about Java and C#?

(1)

Building a C++ Program

(3)

Enter the Program Statements

(1)

Build the Program (Compile and Link)

(1)

Test the Program

(1)

Revise As Needed

(1)

Installing Your Own C++ Compiler

(1)

Print a Message

(5)

If You're Using the RHIDE Environment

(1)

If You're Using Microsoft Visual Studio

(1)

How It Works

(2)

Exercises

(1)

Interlude What about #include and ``using''?

(1)

Advancing to the Next Print Line

(1)

Print Multiple Lines

(2)

How It Works

(1)

Exercises

(1)

Interlude What Is a String?

(1)

Storing Data: C++ Variables

(1)

Introduction to Data Types

(2)

Interlude Why Double Precision, Not Single?

(1)

Convert Temperatures

(6)

How It Works

(2)

Variations on the Example

(2)

Exercises

(1)

A Word about Variable Names and Keywords

(1)

Exercise

(1)

Chapter 1 Summary

(3)

Decisions, Decisions

(32)

But First, a Few Words about Data Types

(4)

Interlude For C Programmers

(1)

Decision Making in Programs

(1)

If and if-else

(4)

Interlude Why Two Operators (= and ==)?

(1)

Odd or Even?

(3)

How It Works

(1)

Optimizing the Code

(1)

Exercise

(1)

Introducing Loops

(4)

Interlude Infinite Loopiness

(1)

Print 1 to N

(2)

How It Works

(1)

Exercises

(1)

True and False in C++

(1)

Interlude The bool Data Type

(1)

The Increment Operator (++)

(2)

Statements vs. Expressions

(1)

Introducing Boolean (Short-Circuit) Logic

(2)

Interlude What Is ``true''?

(1)

Testing a Person's Age

(1)

How It Works

(1)

Exercise

(1)

Introducing the Math Library

(1)

Prime-Number Test

(3)

How It Works

(1)

Optimizing the Program

(1)

Exercise

(1)

Chapter 2 Summary

(4)

The Handy, All-Purpose ``for'' Statement

(16)

Loops Used for Counting

(1)

Introducing the ``for'' Loop

(2)

A Wealth of Examples

(2)

Interlude Does ``for'' Always Behave like ``while''?

(1)

Printing 1 to N with ``for''

(1)

How It Works

(1)

Exercises

(1)

Statement Blocks with ``for''

(1)

Declaring Loop Variables on the Fly

(1)

Prime-Number Test with ``for''

(4)

How It Works

(2)

Exercise

(1)

Comparative Languages 101: The Basic ``for'' Statement

(1)

Chapter 3 Summary

(3)

Functions: Many Are Called

(30)

The Concept of Function

(2)

Function Calls and the Flow of the Program

(1)

The Basics of Using Functions

(4)

Step One: Declare (Prototype) the Function

(1)

Step Two: Define the Function

(1)

Step Three: Call the Function

(1)

Triangle-Number Function

(4)

How It Works

(1)

Optimizing the Program

(2)

Exercises

(1)

Prime-Number Function

(3)

How It Works

(2)

Exercises

(1)

Local and Global Variables

(2)

Recursive Functions

(1)

Greatest Common Factor (GCF)

(4)

How It Works

100

(1)

Exercises

101

(1)

Prime Factorization

102

(4)

How It Works

103

(2)

Interlude For Math Junkies

105

(1)

Exercises

106

(1)

Random-Number Generator

106

(3)

How It Works

108

(1)

Exercise

109

(1)

Chapter 4 Summary

109

(2)

Arrays: We've Got Their Number

111

(28)

A First Look at C++ Arrays

111

(2)

Initializing Arrays

113

(1)

Zero-Based Indexing

114

(1)

Interlude Why Use Zero-Based Indexes?

114

(1)

Print Out Elements

115

(2)

How It Works

116

(1)

Exercises

117

(1)

How Random Is Random?

117

(5)

How It Works

120

(2)

Exercises

122

(1)

Strings and Arrays of Strings

122

(1)

Card Dealer #1

123

(3)

How It Works

125

(1)

Exercise

126

(1)

Card Dealer #2

126

(4)

How It Works

128

(2)

Exercise

130

(1)

Card Dealer #3

130

(5)

How It Works

132

(2)

Optimizing the Program

134

(1)

Exercise

135

(1)

A Word to the Wise

135

(1)

2-D Arrays: Into the Matrix

136

(1)

Chapter 5 Summary

137

(2)

Pointers: Getting a Handle on Data

139

(24)

The Concept of Pointer

139

(3)

Interlude What Do Addresses Really Look Like?

140

(2)

Declaring and Using Pointers

142

(3)

The Double-It Function

145

(2)

How It Works

145

(2)

Exercises

147

(1)

Swap: Another Function Using Pointers

147

(2)

Array Sorter

149

(5)

How It Works

152

(1)

Exercises

153

(1)

Pointer Arithmetic

154

(2)

Pointers and Array Processing

156

(1)

Zero Out an Array

157

(4)

How It Works

158

(1)

Optimizing the Program

159

(1)

Exercises

160

(1)

Chapter 6 Summary

161

(2)

Strings: Analyzing the Text

163

(34)

Text Storage on the Computer

163

(2)

Interlude How Does the Computer Translate Programs?

164

(1)

It Don't Mean a Thing If It Ain't Got That String

165

(1)

String-Manipulation Functions

166

(2)

Building Strings

168

(4)

How It Works

170

(1)

Exercises

171

(1)

Interlude What about Escape Sequences?

172

(1)

Reading String Input

172

(3)

Get a Number

175

(2)

How It Works

176

(1)

Exercise

177

(1)

Convert to Uppercase

177

(3)

How It Works

178

(1)

Exercises

179

(1)

Individual Characters vs. Strings

180

(1)

Analyze Input

181

(5)

How It Works

183

(2)

Exercises

185

(1)

The New C++ String Class

186

(3)

Include String-Class Support

187

(1)

Declare and Initialize Variables of Type String

187

(1)

Working with Variables of Type String

188

(1)

Input and Output

189

(1)

Building Strings with the string Type

189

(2)

How It Works

190

(1)

Exercises

191

(1)

Other Operations on the string Type

191

(2)

Chapter 7 Summary

193

(4)

Files: Electronic Storage

197

(22)

Introducing File-Stream Objects

197

(2)

How to Refer to Disk Files

199

(1)

Write Text to a File

200

(3)

How It Works

201

(1)

Exercises

202

(1)

Display a Text File

203

(3)

How It Works

204

(1)

Exercises

205

(1)

Text Files vs. ``Binary'' Files

206

(2)

Interlude Are ``Binary Files'' Really More Binary?

208

(1)

Introducing Binary Operations

208

(3)

Random-Access Write

211

(3)

How It Works

213

(1)

Exercises

214

(1)

Random-Access Read

214

(3)

How It Works

216

(1)

Exercises

216

(1)

Chapter 8 Summary

217

(2)

Some Advanced Programming Techniques

219

(26)

Command-Line Arguments

219

(2)

Display File from Command Line

221

(3)

How It Works

223

(1)

Exercises

223

(1)

Function Overloading

224

(2)

Interlude Overloading and OOPS

225

(1)

Printing Different Types of Arrays

226

(2)

How It Works

227

(1)

Exercise

228

(1)

The do-while Loop

228

(2)

The switch-case Statement

230

(1)

Multiple Modules

231

(3)

Exception Handling

234

(5)

Say Hello to Exceptions

234

(1)

Handling Exceptions: A First Attempt

235

(1)

Introducing try-catch Exception Handling

236

(3)

Exception Handling with GCF

239

(3)

How It Works

240

(1)

Exercise

241

(1)

Interlude Can I Use Multiple try-catch Blocks?

241

(1)

Chapter 9 Summary

242

(3)

Getting Yourself Object Oriented

245

(16)

Why Get Object Oriented?

245

(2)

A String Parser

247

(1)

Objects vs. Classes

248

(1)

Another Example: The Fraction Class

249

(1)

Object Creation and Destruction

250

(1)

Inheritance, or Subclassing

251

(1)

Creating Shared Interfaces

252

(1)

Polymorphism: True Object Independence

253

(2)

Polymorphism and Virtual Functions

255

(2)

Interlude Polymorphism and Traditional Languages

256

(1)

What about Reusability?

257

(2)

Chapter 10 Summary

259

(2)

The Fraction Class

261

(30)

Point: A Simple Class

261

(2)

Interlude For C Programmers: Structures and Classes

263

(1)

Private: Members Only (Protecting the Data)

263

(3)

Testing the Point Class

266

(2)

How It Works

267

(1)

Exercises

268

(1)

Introducing the Fraction Class

268

(3)

Inline Functions

271

(2)

Find the Greatest Common Factor

273

(2)

Find the Lowest Common Multiple

275

(1)

Fraction Support Functions

276

(4)

How It Works

278

(1)

Exercises

279

(1)

Testing the Fraction Class

280

(3)

How It Works

282

(1)

Exercise

283

(1)

Interlude A New Kind of #include?

283

(1)

Fraction Arithmetic: add and mult

283

(5)

How It Works

287

(1)

Exercises

288

(1)

Chapter 11 Summary

288

(3)

Constructors: If You Build It . . .

291

(22)

Introducing Constructors

291

(2)

Multiple Constructors (Overloading)

293

(1)

The Default Constructor...and a Warning

294

(2)

Interlude Is C++ Out to Trick You with the Default Constructor?

295

(1)

Point Class Constructors

296

(3)

How It Works

298

(1)

Exercises

298

(1)

Fraction Class Constructors

299

(3)

How It Works

301

(1)

Exercises

302

(1)

Reference Variables and Arguments (&)

302

(2)

The Copy Constructor

304

(2)

Interlude The Copy Constructor and References

305

(1)

Fraction Class Copy Constructor

306

(4)

How It Works

309

(1)

Exercises

310

(1)

Chapter 12 Summary

310

(3)

Operator Functions: Doing It with Class

313

(30)

Introducing Class Operator Functions

313

(3)

Operator Functions As Global Functions

316

(2)

Improve Efficiency with References

318

(2)

Point Class Operators

320

(3)

How It Works

322

(1)

Exercises

323

(1)

Fraction Class Operators

323

(5)

How It Works

326

(2)

Exercises

328

(1)

Working with Other Types

328

(1)

The Class Assignment Function (=)

329

(1)

The Test-for-Equality Function (==)

330

(2)

Interlude What about the Boolean Type (bool)?

331

(1)

A Class ``Print'' Function

332

(1)

The Completed Fraction Class

333

(6)

How It Works

337

(1)

Exercises

338

(1)

Chapter 13 Summary

339

(4)

What's ``new'': The StringParser Class

343

(20)

The ``new'' Operator

343

(2)

Objects and ``new''

345

(2)

Allocating Array Data

347

(2)

Interlude Dealing with Problems in Memory Allocation

348

(1)

Dynamic Memory in Action

349

(1)

How It Works

350

(1)

Exercise

350

(1)

Design for a Parser (Lexical Analyzer)

350

(5)

The StringParser Class

355

(6)

How It Works

358

(2)

Improving the Code

360

(1)

Exercises

360

(1)

Chapter 14 Summary

361

(2)

What's ``this'': The String Class

363

(22)

Introducing the String Class

363

(1)

Introducing Class Destructors

364

(2)

A Simple String Class

366

(4)

How It Works

367

(3)

Exercises

370

(1)

``Deep'' Copying and the Copy Constructor

370

(2)

The ``this'' Keyword

372

(2)

Revisiting the Assignment Operator

374

(1)

Writing a Concatenation Function

375

(2)

The Complete String Class

377

(5)

How It Works

380

(1)

Exercises

381

(1)

Chapter 15 Summary

382

(3)

Inheritance: What a Legacy

385

(28)

Subclassing for Fun and Profit

385

(4)

Interlude Why ``public'' Base Classes?

388

(1)

The FloatFraction Class

389

(5)

How It Works

393

(1)

Exercises

394

(1)

Problems with the FloatFraction Class

394

(4)

Default Constructors for Subclasses

396

(1)

Copy Constructors for Subclasses

396

(1)

Assignment Function for Subclasses

396

(1)

Add the Missing Constructors

396

(1)

Resolving Type Conflicts with the Base Class

397

(1)

The Completed FloatFraction Class

398

(1)

How It Works

399

(1)

Exercises

399

(1)

The ProperFraction Class

399

(5)

How It Works

402

(2)

Exercises

404

(1)

Private and Protected Members

404

(2)

Contained Members: FractionUnits

406

(4)

How It Works

408

(2)

Exercise

410

(1)

Chapter 16 Summary

410

(3)

Polymorphism: Object Independence

413

(22)

A Different Approach to the FloatFraction Class

413

(2)

Virtual Functions to the Rescue!

415

(3)

Interlude What Is the Virtual Penalty?

416

(2)

The Revised FloatFraction Class

418

(5)

How It Works

420

(1)

Improving the Code

421

(2)

Exercise

423

(1)

``Pure Virtual'' and Other Arcane Matters

423

(1)

Abstract Classes and Interfaces

424

(2)

Why cout Is Not Truly Polymorphic

426

(1)

True Polymorphism: The Printable Class

427

(4)

How It Works

429

(2)

Exercise

431

(1)

A Final Word (or Two)

431

(1)

A Final Final Word

432

(1)

Chapter 17 Summary

433

(2)

Appendix A C++ Operators

435

(4)

Appendix B Intrinsic Data Types

439

(2)

Appendix C C++ Syntax Summary

441

(10)

Literal Constants

441

(1)

Basic Expression Syntax

441

(1)

Basic Statement Syntax

442

(1)

Control Structures

443

(2)

Special Control Statements

445

(1)

Data Declarations

446

(1)

Function Declarations

447

(1)

Class Declarations

448

(3)

Appendix D ASCII Codes

451

(2)

Appendix E Common Library Functions

453

(6)

String Functions

453

(1)

Data-Conversion Functions

454

(1)

Single-Character Functions

455

(1)

Math Functions

455

(2)

Randomization

457

(2)

Appendix F Glossary of Terms

459

(10)

Index

469

Please wait while the item is added to your bag...

FREE SHIPPING

Amazon no longer offers textbook rentals. We do!

C++ Without Fear : A Beginner's Guide That Makes You Feel Smart

Summary

Author Biography

Table of Contents

Supplemental Materials