1: intro to c++ syntax

  - intro to c++
  - examining our first program
  - building a c++ program
  - comments in c++
  - variables in c++
  - reading input into variables
  - some points about variables
  - variable initializations
  - other arithmetic operators
  - precedence
  - the using statement
  - c++ string i/o

2: control statements

  - simple conditional statements
  - relational operators
  - arithmetic expressions - shortcuts
  - arithmetic expressions - prefix vs postfix
  - compound conditional statement
  - control structures - big if/else
  - switch statements
  - control structures - loops
  - control structures - the continue statement
  - differentiating between = and == 

3: functions

- functions in c++
- global functiona
- argument/type coercion
- scope
- function declaration/definition
- argument passing
- why use pass by reference?
- function overloading
- ambiguous access

4: more functions, intro to classic arrays

- function templates
- calling function templates
- about stack frames
- recursion
- inline functions
- default arguments
- classic arrays
- static initializations
- writing to arrays
- enumerations

5: classes, part i

- intro
- what is a class
- classes
- classes: public vs. private
- classes: lots of member functions
- classes: more public vs. private
- where are member functions defined?
- what files should these definitions go in
- constructors
- a counter class
- constructors with arguments
- overloaded constructors

6: pointers

- pointers
- dynamic allocation
- accessing content
- pointers to existing variables
- pointers chaos
- allocating user-defined types
- accessing members via pointers
- passing arguments by pointer
- using const with pointers
- nonconstant pointer, nonconstant data
- constant pointer, nonconstant data
- constant pointer, constant data
- pointers and arrays
- pointer arithmetic
- back to arrays
- pointers as parameters
- dynamic allocation of arrays

7: c and c++ strings

- pointer based (c-style strings)
- arguments to main()
- the sizeof() operator
- c string library
- strlen
- strcpy
- strcmp
- c++ strings
- c++ string calls
- standard template library
- introduction to vectors
- initializing vectors
- using [] with vectors

8: classes - part ii

- classes
- a custom string class
- interface vs. implementation
- some minor additions
- implicit inlining
- multiple constructors
- destructor
- constructors & destructors
- returning references
- default assignment
- const in classes
- this
- person class
- static members

9: operator overloads

- more on function overloading
- operator overloading
- unary operator overloading
- binary operator overloads
- special binary overloads
- problems with emojis
- diversion: copy constructors
- copy constructors
- overloading assignment
- overloading << and >>
- overloading <<
- overloading >>

10: inheritance

- the conceptual side of classes
- inheritance
- protected members
- cleaning up our implementation
- overriding
- virtual functions

11: polymorphism

- inheritance -- review
- polymorphism
- shape class without polymorphism
- expanding the class
- square class
- shape class with polymorphism
- adding a shape
- polymorphism
- abstract classes

12: exceptions

   - catching
   - throwing
   - stack unwinding
   - w/ inheritance
   - bad_alloc
   - nullptr
   - w/ function/method declarations

13: things in c++ 11 that make things easier

   - auto
   - delegating constructor
   - unified initialization syntax
   - scoped enumerations
   - c++ array style
   - bounds checking
   - range based for
   - sorting
   - searching
   - null ptr

14: function pointers, lambda expressions

   - function pointers
   - pointers to functions
   - function pointers + lambdas
   - lambda expressions
   - passing lambdas as parameters
   ~ call me with function pointer
   ~ call me with std::function
   ~ call me without specifying type
   - capturing local variables
   - capturing variables by reference

15: standard template library

   - the standard template library
   - nested classes
   - stl: iterators
   - stl: review of vectors
   ~ vectors and iterators
   - vector summary
   - stl: maps
   - adapters
   - stack adapters

16: custom templates

   - template functions
   - overloading operations
   - specializations
   - template classes
   - non-type parameters
   - default arguments
   - templates as arguments to templates

17: smart pointers

   - shared_ptr
   - shared_ptr - custom deleter
   - shared_ptr - get classic pointer
   -shared_ptr - simple case study
   - weak pointers + weak_ptr
   - weak_ptr + the lock() method
   - weak_ptr + using shared_ptr constructor
   - weak_ptr - creating

18: casting, stl alorithms

   - casting
   - dangerous casting
   - const+ casting
   - dynamic casting
   - stl algorithms

19: r-value l-value + more semantics

   - l values
   - r values
   - l value references
   - r value references
   - the “problem” with r values
   - sample class
   - problems
   - excessive copies
   - move semantics
   - rule of five
   - move constructor

20: files

   - files
   - writing to a file
   - ofstram
   - reading data from a file
   - ifstream
   - sequential files
   - random access files

21: more abt stl

   - trying to avoid copies
   - avoiding copies
   - using range based for loops with maps
   - range based for - unintentional copies
   - stl algorithms

22: bitwise operations, more on streams

   - bitwise operations
   - bitwise and ( & )
   - bitwise or ( | )
   - why use bitwise operators
   - what are streams
   - types of streams
   - simple stream i/o
   - get and getline
   - stream manipulators
   - floating point precision
   - field width
   - stream error states
   - dealing with bad stream input

23: multiple inheritance

   - what is multiple inheritance
   - what is a mix-in
   - more on multiple inheritance
   - virtual base classes
   - multiple inheritance + ambiguity