Sams Teach Yourself C++ in 24 Hours, Complete Starter Kit

Jesse Liberty is the president of Liberty Associates, Inc. (http://www.LibertyAssociates.com) where he provides training and custom programming. Jesse is the author of numerous books on C++, C#, Web development, and object-oriented analysis and design. He was a Distinguished Software Engineer for AT&T and Vice President of CitibankÕs Development Division.

(NOTE: Hour 1 to Hour 25 conclude with a Summary and a Question and Answer section).

Introduction.
I. INTRODUCING C++.

Hour 1—Getting Started.


Preparing to Program. C++, ANSI C++, ISO C++, Windows, and Other. Areas of Confusion. Installing and Setting Up the Compiler. Compiling and Linking the Source Code. The Development Cycle. HELLO.CPP—Your First C++ Program. Compile Errors.



Why C++ Is the Right Choice. The Parts of a Simple Program. Comments. Functions.

Hour 3—Variables and Constants.


What Is a Variable? Defining a Variable. Creating More Than One Variable at a Time. Assigning Values to Your Variables. Typedef. When to Use short and When to Use long. Constants. Enumerated Constants.

Hour 4—Expressions and Statements.


Statements. Expressions. Operators. Combining the Assignment and Mathematical Operators. Increment and Decrement. Precedence. Nesting Parentheses. The Nature of Truth. Relational Operators. The if Statement. Use Braces in Nested if Statements. Logical Operators. Relational Precedence. More About Truth and Falsehood.

Hour 5—Functions.


What Is a Function? Declaring and Defining Functions. Local Variables. Global Variables. Function Statements. Function Arguments. Parameters Are Local Variables. Return Values. Default Parameters. Overloading Functions.

Hour 6—Program Flow.


Looping. while Loops. do...while Loops. for Loops. switch Statements.

II. CLASSES.

Hour 7—Basic Classes.


What Is a Type? Creating New Types. Classes and Members. Accessing Class Members. Private Versus Public. Implementing Class Methods. Constructors and Destructors.

Hour 8—More About Classes.


const Member Functions. Interface Versus Implementation. Where to Put Class Declarations and Method Definitions. Inline Implementation. Classes with Other Classes as Member Data.

III. MEMORY MANAGEMENT.

Hour 9<107>Pointers.


What Is a Pointer? Why Would You Use Pointers? The Stack and the Heap.

Hour 10—Advanced Pointers.


Creating Objects on the Heap. Deleting Objects. Accessing Data. Members Using Pointers. Member Data on the Heap. The this Pointer. What's the this Pointer For? Stray or Dangling Pointers. const Pointers.

Hour 11—References.


What Is a Reference? Creating a Reference. Using the Address of Operator on References. What Can Be Referenced? Null Pointers and Null References. Passing Function Arguments by Reference. Understanding Function Headers and Prototypes. Returning Multiple Values.

Hour 12—Advanced References and Pointers.


Passing by Reference for Efficiency. References as an Alternative to Pointers. When to Use References and When to Use Pointers. Don't Return a Reference to an Object That Isn't in Scope! Returning a Reference to an Object on the Heap. Pointer, Pointer, Who Has the Pointer?

IV. POWER TOOLS.

Hour 13—Advanced Functions.


Overloaded Member Functions. Using Default Values. Choosing Between Default Values and Overloaded Functions. Overloading Constructors. Initializing Objects. The Copy Constructor.

Hour 14—Operator Overloading.


Operator Overloading. Conversion Operators.

Hour 15—Arrays.


What Is an Array? Array Elements. Writing Past the End of an Array. Fence Post Errors. Initializing Arrays. Arrays of Objects. Multidimensional Arrays. A Word About Memory. Arrays of Pointers. Declaring Arrays on the Heap. A Pointer to an Array Versus an Array of Pointers. Pointers and Array Names. Deleting Arrays on the Heap. char Arrays. strcpy() and strncpy(). String Classes.

V. INHERITANCE AND POLYMORPHISM.

Hour 16—Inheritance.


What Is Inheritance? Private Versus Protected. Constructors and Destructors. Overriding Functions.

Hour 17—Polymorphism and Derived Classes.


Polymorphism Implemented With Virtual Methods.

Hour 18—Advanced Polymorphism.


Problems with Single Inheritance. Abstract Data Types.

Hour 19—Linked Lists.


Linked Lists and Other Structures. A Case Study. The Component Parts. What Have You Learned, Dorothy?

VI. SPECIAL TOPICS.

Hour 20—Special Classes, Functions, and Pointers.


Static Member Data. Static Member Functions. Containment. Friend Classes. Friend Functions. Pointers to Functions. Pointers to Member Functions.

Hour 21—The Preprocessor.


The Preprocessor and the Compiler. Seeing the Intermediate Form. Using #define. Inclusion and Inclusion Guards. Macro Functions. String Manipulation. Predefined Macros.

Hour 22—Object-Oriented Analysis and Design.


The Development Cycle. Simulating an Alarm System. PostMaster: A Case Study.

Hour 23—Templates.


What Are Templates? Parameterized Types. Template Definition. Using Template Items. The Standard Template Library.

Hour 24—Exceptions and Error Handling.


Bugs, Errors, Mistakes, and Code Rot. Exceptions. Using try Blocks and catch Blocks. Next Steps. Style. Next Steps.

VII. APPENDICES.

Appendix A. Binary and Hexadecimal.
Appendix B. Glossary.
Index.