Liberty Jesse, Cadenhead Rogers. Teach Yourself C++ in 24 Hours

5th edition. — Sams, 2011. — 456 p.In just 24 lessons of one hour or less, you can learn the basics of programming with C++–one of the most popular and powerful programming languages ever created.Using a straightforward, step-by-step 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 coming in C++0x, the next version of C++.Each lesson builds on what you’ve already learned, giving you a solid understanding of the basics of C++ programming concepts and techniques.Beginning C++.
HOUR 1: Writing Your First Program.
Using C++.
Finding a Compiler.
Compiling and Linking the Source Code.
Creating Your First Program.
HOUR 2: Organizing the Parts of a Program.
Reasons to Use C++.
The Parts of a Program.
Comments.
Functions.
HOUR 3: Creating Variables and Constants.
What Is a Variable?
Defining a Variable.
Assigning Values to Variables.
Using Type Definitions.
Constants.
HOUR 4: Using Expressions, Statements, and Operators.
Statements.
Expressions.
Operators.
If-Else Conditional Statements.
Logical Operators.
Tricky Expression Values.
HOUR 5: Calling Functions.
What Is a Function?
Declaring and Defining Functions.
Using Variables with Functions.
Function Parameters.
Returning Values from Functions.
Default Function Parameters.
Overloading Functions.
HOUR 6: Controlling the Flow of a Program.
Looping.
while Loops.
do-while Loops.
for Loops.
switch Statements.
HOUR 7: Storing Information in Arrays and Strings.
What Is an Array?
Writing Past the End of Arrays.
Initializing Arrays.
Multidimensional Arrays.
Character Arrays.
Copying Strings.
Classes.
HOUR 8: Creating Basic Classes.
What Is a Type?
Creating New Types.
Classes and Members.
Accessing Class Members.
Private Versus Public Access.
Implementing Member Functions.
Creating and Deleting Objects.
HOUR 9: Moving into Advanced Classes.
const Member Functions.
Interface Versus Implementation.
Organizing Class Declarations and Function Definitions.
Inline Implementation.
Classes with Other Classes as Member Data.
Memory Management.
HOUR 10: Creating Pointers.
Understanding Pointers and Their Usage.
The Stack and the Heap.
HOUR 11: Developing Advanced Pointers.
Creating Objects on the Heap.
Deleting Objects.
Accessing Data Members Using Pointers.
Member Data on the Heap.
The this Pointer.
Stray or Dangling Pointers.
const Pointers.
const Pointers and const Member Functions.
HOUR 12: Creating 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 13: Developing Advanced References and Pointers.
Passing by Reference for Efficiency.
Passing a const Pointer.
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?
Advanced C++.
HOUR 14: Calling Advanced Functions.
Overloaded Member Functions.
Using Default Values.
Initializing Objects.
The Copy Constructor.
HOUR 15: Using Operator Overloading.
Operator Overloading.
Conversion Operators.
Part V: Inheritance and Polymorphism.
HOUR 16: Extending Classes with Inheritance.
What Is Inheritance?
Private Versus Protected.
Constructors and Destructors.
Passing Arguments to Base Constructors.
Overriding Functions.
HOUR 17: Using Polymorphism and Derived Classes.
Polymorphism Implemented with Virtual Methods.
How Virtual Member Functions Work.
HOUR 18: Making Use of Advanced Polymorphism.
Problems with Single Inheritance.
Abstract Data Types.
HOUR 19: Storing Information in Linked Lists.
Linked Lists and Other Structures.
Linked List Case Study.
Linked Lists as Objects.
Special Topics.
HOUR 20: Using Special Classes, Functions, and Pointers.
Static Member Data.
Static Member Functions.
Containment of Classes.
Friend Classes and Functions.
HOUR 21: Using New Features of C++0x.
The Next Version of C++.
Null Pointer Constant.
Compile-Time Constant Expressions.
Auto-Typed Variables.
New for Loop.
HOUR 22: Employing Object-Oriented Analysis and Design.
The Development Cycle.
Simulating an Alarm System.
PostMaster: A Case Study.
HOUR 23: Creating Templates.
What Are Templates?
Instances of the Template.
Template Definition.
Using Template Items.
HOUR 24: Dealing with Exceptions and Error Handling.
Bugs, Errors, Mistakes, and Code Rot.
Handling the Unexpected.
Exceptions.
Using try and catch Blocks.
Writing Professional-Quality Code.
Appendices.
Binary and Hexadecimal.
Other Bases.
Around the Bases.
Hexadecimal.This Book’s Website.