Introduction and Overview

• Relating C, C++, Java and C#
• The in-class development environment
• Other development environments

C++ Programming Building Blocks

The main function and standard I/O

• main's specification and body
• Displaying values and strings to cout
• Reading values from cin
• Formatting with stream manipulators

Objects, constants and references

• Declaring and initialising variables
• Integer and floating point data types
• Performing arithmetic calculations and displaying results
• Passing messages to objects
• Using references for efficiency and constants for safety

Defining and calling functions

• Passing arguments to functions and returning values from functions
• Call-by-value vs. call-by-reference vs. call-by-address
• Scope, duration and initial values of local temporary and parameter variables

Decisions, loops and logic

• Making decisions with if/else
• bool vs. int logical values
• if/else statement "chains"
• Performing loops with while and for
• Equality, relational and logical operators
• Increment and decrement operators

Arrays, pointers and strings

• Declaring and using arrays and pointers
• Storing strings in character arrays
• Accessing array elements via pointers
• Pointers vs. references
• Standard string class and functions

Defining C++ Classes and Objects

Encapsulating higher-level data types

• Public member functions and private data members
• Protected class members
• Constructors and destructors
• Member initialisation syntax
• Self-reference: the this pointer
• The class member operator (::)

Declaring, accessing and modifying objects

• Manipulating arrays of objects, pointers to objects and references to objects
• Invoking member functions
• const member functions
• Passing objects by value and by reference

Overloading and templates

• Simplifying class interfaces
• Function signatures
• Overloading assignment (=) and insertion (<<)
• friend functions and classes
• Explicit copy construction
• Avoiding default assignment and default copy construction
• Using STL templates to define families of related classes

Separating interfaces and implementations

• How separation supports code reuse
• Building header files and code files

Extending Classes via Inheritance

Deriving new classes from existing classes

• Construction and destruction of derived objects
• Is-a-kind-of relationships
• Reusability via incremental extensions
• Base classes and derived classes

Utilising polymorphic functions

• Overriding virtual base class member functions in derived classes
• Runtime lookup of functions through base class pointers and references

Managing dynamic data

• Allocating and deallocating memory with new and delete
• Handling errors with try and catch
• Avoiding memory leaks

Standards and Extensions

• Standard vs. platform-specific implementations
• Applicability to Windows and UNIX/Linux
• Managed C++, C++/CLI and other extensions