Learn By Example: C++ Programming – 75 Solved Problems

Course Curriculum

Chapter 1: Introducing C++

Lecture 1: Introducing C++

Chapter 2: Moving from C to C++

Lecture 1: C and C++ – similar in some ways but actually very different

Lecture 2: C vs C++: Comments are different – and oh C++ has namespaces!

Lecture 3: Namespaces? Then we need a scope resolution operator

Lecture 4: Not just function overloading, C++ allows operator overloading as well!

Lecture 5: Default Values

Lecture 6: References, Const and Bool

Chapter 3: Objects and Classes

Lecture 1: Classes mean different things to different people!

Lecture 2: Classes – A logical grouping of data and functions

Lecture 3: Example 1 and 2: Define a really simple C++ class and instantiate it

Lecture 4: Example 3: Invoke the member functions of an object

Lecture 5: Example 4 and 5: Setup and clean up using constructors and destructors

Lecture 6: Example 6: Access Modifiers

Chapter 4: Multi-file Programs

Lecture 1: Example 7: Separating code into .cpp and .h files

Lecture 2: Example 7: Setting up dependencies with multiple files

Chapter 5: Dynamic Memory Allocation: new and delete

Lecture 1: Dynamic Memory Allocation

Lecture 2: C++ memory allocation explained

Lecture 3: Stop using malloc and free

Lecture 4: Do not mix new/delete for single variables with array equivalents new[]/delete[]

Lecture 5: Example 8 and 9: Stop using malloc and free, use new and delete instead!

Lecture 6: Example 10 and 11: Use new[] and delete [] for arrays – never mix new and new[]

Lecture 7: Example 12: The Placement new operator and the "this" pointer

Chapter 6: The C++ string Class

Lecture 1: The C++ string class

Lecture 2: Example 14: Strings

Lecture 3: Example 15: Inputing multiline strings

Lecture 4: Example 16: More common string operations

Lecture 5: Example 17: Comparing strings

Lecture 6: Example 18: Converting C++ to C strings (and vice versa)

Chapter 7: References

Lecture 1: The basic idea of references

Lecture 2: Example 19, 20 and 21: A simple reference, a const reference, and C++ swap

Lecture 3: Example 22, 23, 24, 25: Reference initialization, reassignment, aliasing, null

Lecture 4: Example 26, 27, 28, 29: References to pointers, references as return types

Chapter 8: The const Keyword

Lecture 1: Example 30 and 31: The C++ const keyword

Lecture 2: Example 32: const char* or char* const?

Lecture 3: Example 33, 34, 35, 36: Const methods, mutable, overloading on const, const_cast

Lecture 4: Passing function parameters const references

Lecture 5: Example 37: Passing function parameters const references

Chapter 9: The static Keyword

Lecture 1: The basic idea of static in C++

Lecture 2: Example 38: Static member variables

Lecture 3: Example 39 and 40: Static member functions

Lecture 4: Example 41: const static member variables

Chapter 10: The friend Keyword

Lecture 1: The basic idea of friends in C++

Lecture 2: Example 42: Friend functions

Lecture 3: Example 43: Friend classes

Chapter 11: Operator Overloading

Lecture 1: Understanding operator overloading – internal and external operators

Lecture 2: Choosing between internal and external implementations

Lecture 3: Example 44: Overloading the += operator

Lecture 4: Example 45: Overloading the + operator

Lecture 5: Example 46: Overloading the ++ (and –) operators

Lecture 6: Example 47: Overloading the assignment operator

Lecture 7: Operator Overloading – Streams Flashback

Lecture 8: Example 48: Overloading the << and >> operators

Chapter 12: Inheritance

Lecture 1: Understanding inheritance – Flashback to objects and classes

Lecture 2: Example 49 Understanding Inheritance

Lecture 3: Inheritance Explained – I

Lecture 4: Inheritance Explained – II

Lecture 5: Example 49: Access levels and inheritance types

Lecture 6: Example 49: Bringing all inheritance concepts together in code

Lecture 7: Examples 50, 51, 52: Types of inheritance

Lecture 8: Example 53: virtual functions

Lecture 9: Example 53 (continued)

Lecture 10: Example 54: pure virtual functions and abstract classes

Lecture 11: Example 55: Multiple Inheritance, and a Diamond Hierarchy

Lecture 12: Example 56: Virtual inheritance in a Diamond Hierarchy

Lecture 13: Example 57: Object Slicing

Lecture 14: Example 58: No virtual function calls in constructors or destructors!

Lecture 15: Example 59: Virtual destructors rock!

Lecture 16: Example 60: Why virtual functions should never have default parameters

Lecture 17: Example 61: The strange phenomenon of name hiding

Lecture 18: Example 62: Never redefine non-virtual base class methods

Chapter 13: Templates

Lecture 1: Templates as a form of generic programming

Lecture 2: Example 63: A simple template function

Lecture 3: Example 64: Overriding a default template instantiation

Lecture 4: Example 65: A templated smart pointer class

Lecture 5: Example 66: Template Specialisation (partial or total)

Chapter 14: STL – The Standard Template Library

Lecture 1: Introducing the Standard Template Library

Lecture 2: Example 67: The STL vector

Lecture 3: Example 68: Iterators

Lecture 4: Example 69: map, an associative container

Lecture 5: Example 70: STL algorithms

Chapter 15: C++ Casts

Lecture 1: C++ casts are way cooler than C casts

Lecture 2: Example 71: const_cast

Lecture 3: Example 72: dynamic_cast, and RTTI

Lecture 4: Example 73: static_cast, and the explicit keyword

Chapter 16: Exceptions