Hjem

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 Function