C++ in 24 Hours, Sams Teach Yourself: (Sams Teach Yourself)

Sams Teach Yourself C++ in 24 Hours is a hands-on guide to the C++ programming language. Readers are provided with short, practical examples that illustrate key concepts, syntax, and techniques. Using a straightforward approach, this fast and friendly tutorial teaches you everything you need to know, from installing and using a compiler, to debugging the programs you’ve created, to what’s new in C++14. Step-by-step instructions carefully walk you through the most common C++ programming tasks Quizzes and exercises at the end of each chapter help you test yourself to make sure you’re ready to go on Learn how to... Install and use a C++ compiler for Windows, Mac OS X, or Linux Build object-oriented programs in C++ Master core C++ concepts such as functions and classes Add rich functionality with templates and lambda expressions Debug your programs for flawless code Learn exception and error-handling techniques Put to use the new features in C++14, the latest version of the language Create and use templates Control program flow with loops Store information in arrays and strings Declare and use pointers Use operator overloading Extend classes with inheritance Use polymorphism and derived classes Employ object-oriented analysis and design

Table of Contents:
 Introduction     1 PART I:  BEGINNING C++ Hour 1:  Writing Your First Program     5 Using C++     5 Compiling and Linking the Source Code     6 Creating Your First Program     7 Hour 2:  Organizing the Parts of a Program     13 Reasons to Use C++     13 The Parts of a Program     17 Comments     19 Functions     20 Hour 3:  Creating Variables and Constants     27 What Is a Variable?     27 Defining a Variable     32 Assigning Values to Variables     33 Using Type Definitions     34 Constants     36 Auto-Typed Variables     38 Hour 4:  Using Expressions, Statements, and Operators     43 Statements     43 Expressions     44 Operators     45 If-Else Conditional Statements     52 Logical Operators     56 Tricky Expression Values     58 Hour 5:  Calling Functions     61 What Is a Function?     61 Declaring and Defining Functions     61 Using Variables with Functions     64 Function Parameters     67 Returning Values from Functions     68 Default Function Parameters     70 Overloading Functions     72 Auto-Typed Return Values     73 Hour 6:  Controlling the Flow of a Program     79 Looping     79 while Loops     79 do-while Loops     83 for Loops     84 switch Statements     89 Hour 7:  Storing Information in Arrays and Strings     95 What Is an Array?     95 Writing Past the End of Arrays     97 Initializing Arrays     98 Multidimensional Arrays     99 Character Arrays     102 Copying Strings     104 Reading Arrays with Foreach Loops     105 PART II:  CLASSES Hour 8:  Creating Basic Classes     109 What Is a Type?     109 Creating New Types     110 Classes and Members     110 Accessing Class Members     112 Private Versus Public Access     112 Implementing Member Functions     114 Creating and Deleting Objects     116 Hour 9:  Moving into Advanced Classes     123 const Member Functions     123 Interface Versus Implementation     124 Organizing Class Declarations and Function Definitions     124 Inline Implementation     124 Classes with Other Classes as Member Data     127 PART III:  MEMORY MANAGEMENT Hour 10:  Creating Pointers     135 Understanding Pointers and Their Usage     135 The Stack and the Heap     145 Null Pointer Constant     150 Hour 11:  Developing Advanced Pointers     155 Creating Objects on the Heap     155 Deleting Objects     155 Accessing Data Members Using Pointers     157 Member Data on the Heap     158 The this Pointer     160 Stray or Dangling Pointers     161 const Pointers     162 const Pointers and const Member Functions     163 Hour 12:  Creating References     167 What is a Reference?     167 Creating a Reference     167 Using the Address of Operator on References     169 What Can Be Referenced?     171 Null Pointers and Null References     172 Passing Function Arguments by Reference     172 Understanding Function Headers and Prototypes     177 Returning Multiple Values     177 Hour 13:  Developing Advanced References and Pointers     183 Passing by Reference for Efficiency     183 Passing a const Pointer     186 References as an Alternative to Pointers     189 When to Use References and When to Use Pointers     191 References to Objects Not in Scope     191 Returning a Reference to an Object on the Heap     192 Pointer, Pointer, Who Has the Pointer?     195 PART IV:  ADVANCED C++ Hour 14:  Calling Advanced Functions     199 Overloaded Member Functions     199 Using Default Values     201 Initializing Objects     203 The Copy Constructor     204 Compile-Time Constant Expressions     208 Hour 15:  Using Operator Overloading     213 Operator Overloading     213 Conversion Operators     224 PART V:  INHERITANCE AND POLYMORPHISM Hour 16:  Extending Classes with Inheritance     231 What Is Inheritance?     231 Private Versus Protected     234 Constructors and Destructors     236 Passing Arguments to Base Constructors     239 Overriding Functions     244 Hour 17:  Using Polymorphism and Derived Classes     251 Polymorphism Implemented with Virtual Member Functions     251 How Virtual Member Functions Work     256 Hour 18:  Making Use of Advanced Polymorphism     267 Problems with Single Inheritance     267 Abstract Data Types     271 PART VI:  SPECIAL TOPICS Hour 19:  Storing Information in Linked Lists     287 Linked Lists and Other Structures     287 Linked List Case Study     289 Linked Lists as Objects     298 Hour 20:  Using Special Classes, Functions, and Pointers     301 Static Member Data     301 Static Member Functions     303 Containment of Classes     305 Friend Classes and Functions     312 Hour 21:  Using New Features of C++14     331 The Newest Version of C++     331 Using auto in Function Return Types     332 Improved Numeric Literals     334 The constexpr Keyword     335 Lambda Expressions     338 Hour 22:  Employing Object-Oriented Analysis and Design     343 The Development Cycle     343 Simulating an Alarm System     344 PostMaster:  A Case Study     350 Hour 23:  Creating Templates     373 What Are Templates?     373 Instances of the Template     374 Template Definition     374 Using Template Items     381 Hour 24:  Dealing with Exceptions and Error Handling     391 Bugs, Errors, Mistakes, and Code Rot     391 Handling the Unexpected     392 Exceptions     393 Using try and catch Blocks     397 Writing Professional-Quality Code     403 PART VII:  APPENDIXES Appendix A:  Binary and Hexadecimal     411 Other Bases     412 Around the Bases     412 Hexadecimal     416 Appendix B:  Glossary     419 Appendix C:  This Book’s Website     427 Appendix D:  Using the MinGW C++ Compiler on Windows     429 Downloading MinGW-w64     429 Setting the Path Environment Variable     431 Testing Your Installation     433 Index     439