Learn to program with C++ quickly with this helpful For Dummies guideBeginning Programming with C++ For Dummies, 2nd Edition gives you plain-English explanations of the fundamental principles of C++, arming you with the skills and know-how to expertly use one of the world's most popular programming languages.

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

Learn to: Think like a programmer and understand how C++ worksCreate programs and get bugs out of your codeMaster basic development concepts and techniques in C++Work with the Code::Blocks C++ compiler, available online Programming made easy with the definitive guide to the popular C++ language Want to get started with programming but don’t know quite where to begin? This complete guide to learning C++ programming will help you start your journey! Learn to walk the programming walk while figuring out how to use C++, install and use the compiler, work with loops, grasp objects and classes, and write real programs that work. Let’s get started — get a complete grasp of what computers need to work, what algorithms are, and how programming languages functionGet functional — find out how to write simple expressions, declare integer variables, and make decisions within a programExterminate — get the bugs out of your programs with an in-depth look at debugging, unit tests, and using predefined preprocessor commandsTake it one step further — explore more advanced topics on your own, with tips on where to start and how to find more information Open the book and find: How programming languages workHow to master basic development concepts in C++Tips for getting rid of bugs in your codeHow to work with integer and character expressionsThe essential parts of control and looping structuresHow to use constructors and destructorsHow to build data structures that mimic the real worldAdvanced language features to ramp up your code Visit the companion website at www.dummies.com/extras/beginningprogrammingcplusplus for code from the book and an updated C++ compiler.