Beginning Programming with C++ For Dummies

Stephen R. Davis is the bestselling author of numerous books and articles, including C++ For Dummies. He has been programming for over 35 years and currently works for Agency Consulting Group in the area of Cyber Defense.

Introduction 1

About This Book 1

Foolish Assumptions 2

How This Book Is Organized 3

Part I: Getting Started with C++ Programming 3

Part II: Writing a Program: Decisions, Decisions 4

Part III: Becoming a Procedural Programmer 4

Part IV: Data Structures 4

Part V: Object-Oriented Programming 4

Part VI: Advanced Strokes 5

Part VII: The Part of Tens 5

Icons Used in This Book 5

Beyond the Book 6

Where to Go from Here 6

Part I: Getting Started with C++ Programming 7

Chapter 1: What Is a Program? 9

How Does My Son Differ from a Computer? 9

Programming a “Human Computer” 11

Creating the algorithm 11

Setting the tire-changing language 12

Constructing the program 13

Computer processors 17

Computer Languages 17

High-level languages 19

The C++ language 20

Chapter 2: Installing Code::Blocks 21

Reviewing the Compilation Process 21

Installing Code::Blocks 23

Windows installation 23

Ubuntu Linux installation 26

Mac OS installation 27

Setting up Code::Blocks 31

Testing the Code::Blocks Installation 33

Creating the project 34

Testing your default project 37

Chapter 3: Writing Your First Program 41

Creating a New Project 41

Filename extensions 43

Entering Your Program 44

Building the Program 46

Finding What Could Go Wrong 47

Misspelled commands 47

Missing semicolon 49

Using the Online Material 50

Running the Program 51

How the Program Works 51

The template 51

The Conversion program 53

Part II: Writing a Program: Decisions, Decisions 55

Chapter 4: Integer Expressions 57

Declaring Variables 57

Variable names 58

Assigning a value to a variable 59

Initializing a variable at declaration 60

Integer Constants 61

Expressions 62

Binary operators 62

Unraveling compound expressions 63

Unary Operators 65

The Special Assignment Operators 67

Chapter 5: Character Expressions 69

Defining Character Variables 69

Encoding characters 70

Example of character encoding 73

Encoding Strings of Characters 75

Special Character Constants 75

Chapter 6: if I Could Make My Own Decisions 79

The if Statement 79

Comparison operators 80

Say “No” to “No braces” 83

What Else Is There? 84

Nesting if Statements 86

Compound Conditional Expressions 89

Chapter 7: Switching Paths 93

Controlling Flow with the switch Statement 93

Control Fell Through: Did I break It? 96

Implementing an Example Calculator with the switch Statement 97

Chapter 8: Debugging Your Programs, Part I 101

Identifying Types of Errors 101

Avoiding Introducing Errors 102

Coding with style 102

Establishing variable naming conventions 103

Finding the First Error with a Little Help 104

Finding the Run-Time Error 105

Formulating test data 106

Executing the test cases 106

Seeing what’s going on in your program 107

Part III: Becoming a Procedural Programmer 109

Chapter 9: while Running in Circles 111

Creating a while Loop 111

Breaking out of the Middle of a Loop 114

Nested Loops 117

Chapter 10: Looping for the Fun of It 121

The for Parts of Every Loop 121

Looking at an Example 123

Getting More Done with the Comma Operator 125

Chapter 11: Functions, I Declare! 129

Breaking Your Problem Down into Functions 129

Understanding How Functions Are Useful 130

Writing and Using a Function 131

Returning things 132

Reviewing an example 133

Passing Arguments to Functions 135

Function with arguments 136

Functions with multiple arguments 137

Exposing main() 137

Defining Function Prototype Declarations 139

Chapter 12: Dividing Programs into Modules 141

Breaking Programs Apart 141

Breaking Up Isn’t That Hard to Do 142

Creating Factorialcpp 143

Creating an #include file 145

Including #include files 146

Creating maincpp 148

Building the result 149

Using the Standard C++ Library 149

Variable Scope 150

Chapter 13: Debugging Your Programs, Par t 2 151

Debugging a Dys-Functional Program 151

Performing unit level testing 153

Outfitting a function for testing 155

Returning to unit test 159

Part IV: Data Structures 163

Chapter 14: Other Numerical Variable Types 165

The Limitations of Integers in C++ 165

Integer round-off 166

Limited range 166

A Type That “doubles” as a Real Number 167

Solving the truncation problem 168

When an integer is not an integer 168

Discovering the limits of double 169

Variable Size — the “long” and “short” of It 172

How far do numbers range? 174

Types of Constants 175

Passing Different Types to Functions 176

Overloading function names 177

Mixed-mode overloading 177

Chapter 15: Arrays 181

What Is an Array? 181

Declaring an Array 182

Indexing into an Array 183

Looking at an Example 184

Initializing an Array 187

Chapter 16: Arrays with Character 189

The ASCII-Zero Character Array 189

Declaring and Initializing an ASCIIZ Array 190

Looking at an Example 191

Looking at a More Detailed Example 193

Foiling hackers 197

Do I Really Have to Do All That Work? 198

Chapter 17: Pointing the Way to C++ Pointers 203

What’s a Pointer? 203

Declaring a Pointer 204

Passing Arguments to a Function 206

Passing arguments by value 206

Passing arguments by reference 209

Putting it together 211

Reference argument types 213

Playing with Heaps of Memory 214

Do you really need a new keyword? 214

Don’t forget to clean up after yourself 215

Looking at an example 216

Chapter 18: Taking a Second Look at C++ Pointers 221

Pointers and Arrays 221

Operations on pointers 222

Pointer addition versus indexing into an array 224

Using the pointer increment operator 227

Why bother with array pointers? 230

Operations on Different Pointer Types 231

Constant Nags 231

Differences Between Pointers and Arrays 233

My main() Arguments 233

Arrays of pointers 234

Arrays of arguments 235

Chapter 19: Programming with Class 241

Grouping Data 241

The Class 242

The Object 243

Arrays of Objects 244

Looking at an Example 246

Chapter 20: Debugging Your Programs, Par t 3 253

A New Approach to Debugging 253

The solution 254

Entomology for Dummies 255

Starting the debugger 257

Fixing the (first) bug 264

Finding and fixing the second bug 265

Part V: Object-Oriented Programming 269

Chapter 21: What Is Object-Oriented Programming? 271

Abstraction and Microwave Ovens 271

Procedural nachos 273

Object-oriented nachos 273

Classification and Microwave Ovens 274

Why Build Objects This Way? 275

Self-Contained Classes 276

Chapter 22: Structured Play: Making Classes Do Things 277

Activating Our Objects 277

Creating a Member Function 278

Defining a member function 279

Naming class members 280

Calling a member function 281

Accessing other members from within a member function 282

Keeping a Member Function after Class 284

Overloading Member Functions 285

Chapter 23: Pointers to Objects 287

Pointers to Objects 287

Arrow syntax 288

Calling all member functions 288

Passing Objects to Functions 289

Calling a function with an object value 289

Calling a function with an object pointer 290

Looking at an example 292

Allocating Objects off the Heap 296

Chapter 24: Do Not Disturb: Protected Members 299

Protecting Members 299

Why you need protected members 300

Making members protected 301

So what? 303

Who Needs Friends, Anyway? 304

Chapter 25: Getting Objects Off to a Good Start 307

The Constructor 308

Limitations on constructors 309

Can I see an example? 310

Constructing data members 312

Destructors 315

Looking at an example 316

Destructing data members 318

Chapter 26: Making Constructive Arguments 321

Constructors with Arguments 321

Looking at an example 322

Overloading the Constructor 326

The Default default Constructor 330

Constructing Data Members 332

Initializing data members with the default constructor 332

Initializing data members with a different constructor 334

Looking at an example 337

New with C++ 2011 340

Chapter 27: Coping with the Copy Constructor 341

Copying an Object 341

The default copy constructor 342

Looking at an example 344

Creating a Copy Constructor 346

Avoiding Copies 349

Part VI: Advanced Strokes 351

Chapter 28: Inheriting a Class 353

Advantages of Inheritance 354

Learning the lingo 355

Implementing Inheritance in C++ 355

Looking at an example 356

Having a HAS_A Relationship 360

Chapter 29: Are Virtual Functions for Real? 361

Overriding Member Functions 361

Early binding 362

Ambiguous case 364

Enter late binding 366

When Is Virtual Not? 369

Virtual Considerations 371

Chapter 30: Overloading Assignment Operators 373

Overloading an Operator 374

Overloading the Assignment Operator Is Critical 374

Looking at an Example 376

Writing Your Own (or Not) 379

Chapter 31: Performing Streaming I/O 381

How Stream I/O Works 381

Stream Input/Output 383

Creating an input object 383

Creating an output object 385

Open modes 386

What is binary mode? 386

Hey, file, what state are you in? 387

Other Member Functions of the fstream Classes 391

Reading and writing streams directly 393

Controlling format 396

What’s up with endl? 399

Manipulating Manipulators 399

Using the stringstream Classes 400

Chapter 32: I Take Exception! 405

The Exception Mechanism 406

Examining the exception mechanism in detail 408

Special considerations for throwing 409

Creating a Custom Exception Class 410

Restrictions on exception classes 414

Part VII: The Part of Tens 415

Chapter 33: Ten Ways to Avoid Bugs 417

Enable All Warnings and Error Messages 417

Adopt a Clear and Consistent Coding Style 418

Comment the Code While You Write It 419

Single-Step Every Path in the Debugger at Least Once 419

Limit the Visibility 420

Keep Track of Heap Memory 420

Zero Out Pointers after Deleting What They Point To 421

Use Exceptions to Handle Errors 421

Declare Destructors Virtual 422

Provide a Copy Constructor and Overloaded Assignment Operator 422

Chapter 34: Ten Features Not Covered in This Book 423

The goto Command 423

The Ternary Operator 424

Binary Logic 425

Enumerated Types 425

Namespaces 425

Pure Virtual Functions 426

The string Class 426

Multiple Inheritance 427

Templates and the Standard Template Library 427

Lambda Functions 428

Index 429