diff --git a/Tutorials/T07-CppOverview/Slides/T7.pdf b/Tutorials/T07-CppOverview/Slides/T7.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..7a9139ad4e9126edb1bf159dc34f11bfbfe1d1c2
Binary files /dev/null and b/Tutorials/T07-CppOverview/Slides/T7.pdf differ
diff --git a/Tutorials/T07-CppOverview/Slides/T7.tex b/Tutorials/T07-CppOverview/Slides/T7.tex
new file mode 100644
index 0000000000000000000000000000000000000000..51a6c74cf98236cbc7ecac06a9143702b7fcbacb
--- /dev/null
+++ b/Tutorials/T07-CppOverview/Slides/T7.tex
@@ -0,0 +1,871 @@
+% Define Document Class
+% Class Options Include:
+%    notes, notesonly, handout, trans,
+%    hidesubsections, shadesubsections,
+%    inrow, blue, red, grey, brown
+%--------------------------------------------------------------------------
+\documentclass[xcolor=dvipsnames, shownotes, colorlinks]{beamer}
+%--------------------------------------------------------------------------
+
+% -------------------------------------------------------------------------
+% Define Package Theme
+%--------------------------------------------------------------------------
+\usepackage{color}
+\usepackage[T1]{fontenc}
+%% \usepackage{fix-cm}
+\usepackage{hyperref}
+\hypersetup{
+    urlcolor=cyan,
+    linkcolor=white
+}
+\usepackage{subfigure}
+%% \usepackage{xspace}
+\usepackage{}
+\usepackage{enumerate}
+\usetheme{Antibes}
+\setbeamertemplate{sidebar}[right]
+\usepackage{listings} % Code formatting
+\usepackage{lstautogobble}
+%% \usepackage{framed}
+\usepackage{booktabs}
+\usepackage{tabularx}
+\usepackage{marvosym}
+\usepackage{tikz}
+
+\usetikzlibrary{shapes}
+\usetikzlibrary{arrows}
+\usetikzlibrary{calc,positioning}
+
+\setbeamertemplate{caption}[numbered]
+
+\lstset{language=C++,
+basicstyle=\ttfamily,
+keywordstyle=\color{blue}\ttfamily,
+stringstyle=\color{red}\ttfamily,
+commentstyle=\color{ForestGreen}\ttfamily,
+morecomment=[l][\color{magenta}]{\#},
+autogobble=true,
+showstringspaces=false,
+escapeinside={<@}{@>}
+}
+
+%------------------------------------------------------------------------------
+% Commands
+%------------------------------------------------------------------------------
+
+\newcommand*\oldmacro{}%
+\let\oldmacro\insertshorttitle%
+\renewcommand*\insertshorttitle{%
+  \oldmacro\hfill%
+  \insertframenumber\,/\,\inserttotalframenumber}
+
+% Figure Source
+\usepackage[absolute,overlay]{textpos}
+
+\setbeamercolor{framesource}{fg=gray}
+\setbeamerfont{framesource}{size=\tiny}
+
+\newcommand{\source}[1]{\begin{textblock*}{\paperwidth}(-5pt,\textheight)
+    \begin{beamercolorbox}[ht=0.5cm,right]{framesource}
+        \usebeamerfont{framesource}\usebeamercolor[fg]{framesource} Source: {#1}
+    \end{beamercolorbox}
+\end{textblock*}}
+
+%--------------------------------------------------------------------------
+% Presentation Title Slide
+%--------------------------------------------------------------------------
+\title{Introduction to C++}
+\subtitle{CS 2ME3/SE 2AA4}
+\author{Steven Palmer}
+\institute{Department of Computing and Software\\
+McMaster University\\ }
+\date{\today}
+%--------------------------------------------------------------------------
+
+
+% Document
+%  To add notes to the slides use: \note{}
+%  Add \section{} or \subsection{} for use in table of contents
+%--------------------------------------------------------------------------
+\begin{document}
+
+% Create Title Slide
+\begin{frame}
+\maketitle
+\end{frame}
+
+\section[Outline]{}
+% Create Table of Contents Slide - Outline
+\begin{frame}
+\frametitle{Outline}
+  {\hypersetup{linkcolor=black}
+  \tableofcontents
+  }
+\end{frame}
+
+% -----------------------------------------------------
+\section{C++ Basics}
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{C++}
+\begin{itemize}
+\item C++ is a language based on C -- started as an Object Oriented extension to C (originally called ``C with Classes'')
+\item Backwards compatible with C -- any C program will compile (or be made to compile) with C++
+\item Modern C++ standards have added many additional constructs to the language -- both OO related and not 
+\item As a result, C++ is a {\bf very big} language -- this tutorial will cover some basic
+syntax and concepts you will need for the assignments
+\item You will almost certainly need to do some reading/practice on your own to fill in the gaps -- references to good resources are provided on the last slide
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{\texttt{gcc} (the GNU Compiler Collection)}
+\begin{itemize}
+\item In this course we will use \texttt{g++} (part of the GNU Compiler Collection -- \texttt{gcc}) to compile C++ code
+\item Installation:
+\begin{itemize}
+\item Windows:  via \href{http://www.mingw.org/}{MinGW}
+\item Mac: 
+\begin{itemize}
+\item by default \texttt{gcc}/\texttt{g++} is probably available, but this is actually an alias for \texttt{clang}
+\item use \href{https://brew.sh/}{homebrew} or \href{https://www.macports.org/}{macports} to get proper \texttt{gcc}/\texttt{g++}
+\end{itemize}
+\item Linux:  
+\begin{itemize}
+\item likely installed by default
+\item if not check your package manager
+\end{itemize}
+\end{itemize}
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{File Organization}
+\begin{itemize}
+\item C++ uses header files (extension .h) and source files (extension .cpp)
+\item Generally, for every source file you write, you will write an accompanying header file
+\item Header files contain declarations of variables, classes, and functions
+\item Source files contain the definitions of the things defined in the header
+\item More on this later
+\end{itemize}
+\end{frame}
+
+
+
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{Base Types and Derived Types}
+\begin{itemize}
+\item C++ includes the standard base types that you are familiar with:  int, float, double, bool, char, etc.
+\item There is an additional base type called void which is used as the type for functions which do not return anything (there are additional uses of void, but those are beyond the scope of this course)
+\item Note that strings are not a base type in C++
+\item We can build additional derived types using various language constructs (we will focus on enum and class -- discussed later)
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t,fragile]
+\frametitle{Functions}
+\begin{itemize}
+\item Function definitions in C++ use the following syntax:
+\end{itemize}
+\begin{lstlisting}
+type functionName(type p1, type p2, ...) {
+  function body
+}
+\end{lstlisting}
+\begin{itemize}
+\item For example, a function that returns the smallest of 2 integers would be:
+\end{itemize}
+\begin{lstlisting}
+int min(int a, int b){
+  if (a < b)
+    return a;
+  return b;
+}
+\end{lstlisting}
+\end{frame}
+
+
+
+% -----------------------------------------------------
+\begin{frame}[t,fragile]
+\frametitle{Importing Modules}
+\begin{itemize}
+\item We can import modules in C++ by using the include directive (\#include)
+\item Modules that are part of the C++ standard library are imported with angle brackets
+\item Local modules that you have written are included using quotes
+\item For example:
+\end{itemize}
+\begin{lstlisting}
+// this is a C++ std lib module
+#include <iostream>  
+
+// these are local files
+#include "MyModule.h"       
+#include "AnotherModule.h"
+\end{lstlisting}
+\end{frame}
+
+
+
+% -----------------------------------------------------
+\begin{frame}[t,fragile]
+\frametitle{Header Files}
+\begin{itemize}
+\item Local files that you import should always be headers (.h), and never source files (.cpp)
+\item Generally, we use header files to define all of the functions and classes in a corresponding source file
+\item Consider a source file called \texttt{MinMax.cpp} with the following function definitions:
+\end{itemize}
+\begin{lstlisting}
+int min(int a, int b){
+  return (a < b) ? a : b;
+}
+
+int max(int a, int b){
+  return (a > b) ? a : b;
+}
+\end{lstlisting}
+\end{frame}
+
+% -----------------------------------------------------
+\begin{frame}[t,fragile]
+\frametitle{Header Files}
+\begin{itemize}
+\item The corresponding header file, \texttt{MinMax.h}, for this source would simply be declarations of each function:
+\end{itemize}
+\begin{lstlisting}
+int min(int a, int b);
+int max(int a, int b);
+\end{lstlisting}
+\begin{itemize}
+\item An include directive for this header must be added to the top of \texttt{MinMax.cpp} (otherwise the compiler will think you are redeclaring these functions)
+\item Now you can use \texttt{\#include ``MinMax.h''} in any of your other source files to gain access to these functions
+\item We will see how to create header files for class definitions later
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Some Frequently Used Modules}
+\begin{itemize}
+\item The following are some frequently used modules from the standard library:
+\end{itemize}
+\begin{lstlisting}
+#include <iostream>    <@\color{black}\ttfamily console input and output@>
+#include <fstream>     <@\color{black}\ttfamily file input and output@>
+#include <cmath>       <@\color{black}\ttfamily math functions@>
+#include <string>      <@\color{black}\ttfamily string type and functions@>
+#include <vector>      <@\color{black}\ttfamily vector container@>
+#include <list>        <@\color{black}\ttfamily list container@>
+#include <set>         <@\color{black}\ttfamily set container@>
+#include <algorithm>   <@\color{black}\ttfamily common algorithms@>
+\end{lstlisting}
+\end{frame}
+
+
+
+% -----------------------------------------------------
+\begin{frame}[t,fragile]
+\frametitle{Namespaces}
+\begin{itemize}
+\item C++ uses namespaces to provide different scope groups -- this is done to avoid name collisions
+\item All of the functions and classes that are imported from the standard library using the namespace ``std''
+\item To access a namespace, we use the scope resolution operator (::)
+\item For example, if we import the string module from the standard library and wanted to use the string class, we would  use std::string:
+\end{itemize}
+\begin{lstlisting}
+#include <string>
+
+std::string s = "I'm a string";
+\end{lstlisting}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t,fragile]
+\frametitle{Namespaces}
+\begin{itemize}
+\item If we can be sure that no name collisions will happen, it is convenient to just ``use'' a namespace instead of individually scoping everything
+\item We can do this with the \texttt{using} keyword:
+\end{itemize}
+\begin{lstlisting}
+#include <string>
+using namespace std;
+
+string s = "I'm a string";
+\end{lstlisting}
+\begin{itemize}
+\item This is similar to ``import Module'' vs ``from Module import *'' in Python
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\section{Enumerated Types}
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{Enumerated Types}
+\begin{itemize}
+\item Enumerated types are a common programming construct where a type is defined to have a finite set of named values
+\item These names don't actually do anything other than provide distinction between values in a meaningful way -- they are really the same as integers
+\item When used properly they result in much more readable and understandable code
+\item Think, for example, of using 0 through 6 to represent days of the week vs. using an enum with the set of values \{SAT, SUN, MON, TUE, WED, THU, FRI\}
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t,fragile]
+\frametitle{Enumerated Type Example}
+\begin{itemize}
+\item In C++ we can define an enumerated type using the keyword \texttt{enum}:
+\end{itemize}
+\begin{lstlisting}
+enum Color {RED, BLUE, YELLOW};
+
+void colorFunc(Color c){
+  if (c == BLUE)
+    ... 
+  else if (c == RED)
+    ... 
+  else
+    ...
+}
+\end{lstlisting}
+\end{frame}
+
+
+% -----------------------------------------------------
+\section{Classes}
+% -----------------------------------------------------
+\begin{frame}[t,fragile]
+\frametitle{Classes}
+\begin{itemize}
+\item Class syntax is similar to Python and Java
+\item To define a new class called Example, the code looks like this:
+\end{itemize}
+\begin{lstlisting}
+class Example {
+  private:
+    // private fields and methods go here
+  
+  protected:
+    // protected fields and methods go here
+
+  public:
+    // public fields and methods go here
+};
+\end{lstlisting}
+\end{frame}
+
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{Class Access Specifiers}
+\begin{itemize}
+\item Class members all have an associated access specifier (private, protected, or public)
+\item[]
+\item private:
+\begin{itemize}
+\item these members are not visible outside of the class definition
+\item instances cannot access these members
+\item derived classes cannot access these members
+\end{itemize}
+\item protected:
+\begin{itemize}
+\item same as private, except derived classes can access these members
+\end{itemize}
+\item public:
+\begin{itemize}
+\item visible to everyone
+\item class instances and derived classes can access these
+\end{itemize}
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{Constructors}
+\begin{itemize}
+\item All classes have constructors for creating instances of the class
+\item By default, a constructor that takes no parameters exists even if not defined -- this constructor simply creates an instance
+\item Custom constructor declarations/definitions look like normal function declarations/definitions, except they have no return type
+\item Constructors must have the same name as the class
+\item Constructors should always be public, otherwise they can't be accessed by instances
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Constructor Example}
+\begin{lstlisting}
+class Point {
+  private:
+    double x;
+    double y;
+  
+  public:
+    Point() {
+      this->x = 0;
+      this->y = 0;
+    }
+    Point(double x, double y){
+      this->x = x;
+      this->y = y;
+    }
+};
+\end{lstlisting}
+\end{frame}
+
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{\texttt{this}}
+\begin{itemize}
+\item In the example on the previous slide, we saw the keyword \texttt{this}
+\item \texttt{this} behaves like \texttt{self} in Python -- it refers to the calling instance
+\item Note the arrow operator (->) -- you cannot use dot (.) with \texttt{this}
+\item \texttt{this} is available in all class method definitions, not just the constructors
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Classes in Header Files}
+\begin{itemize}
+\item Similar to functions, whenever we define a class we should separate the declaration and the definition into a header file and a source file respectively
+\item Consider the following class definition (next slide)
+\end{itemize}
+\end{frame}
+
+\begin{frame}[t, fragile]
+\frametitle{Classes in Header Files}
+\begin{lstlisting}
+class Point {
+  private:
+    double x;
+    double y;
+  
+  public:
+    Point(double x, double y){
+      this->x = x;
+      this->y = y;
+    }
+    double getX(){ return this->x; }
+    double getY(){ return this-y; }
+};
+\end{lstlisting}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Classes in Header Files}
+\begin{itemize}
+\item To create a header file for this class, we remove the definitions and just give the declarations:
+\end{itemize}
+\begin{lstlisting}
+class Point {
+  private:
+    double x;
+    double y;
+  
+  public:
+    Point(double x, double y);
+    double getX();
+    double getY();
+};
+\end{lstlisting}
+\end{frame}
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Classes in Header Files}
+\begin{itemize}
+\item In the corresponding source file, we don't want to rewrite the class -- the compiler would tell us that it is already defined
+\item All we would like to do is add definitions for the class methods -- that is all that is missing from the header
+\item We can do this using the scope resolution operator:
+\end{itemize}
+\begin{lstlisting}
+#include "Point.h"
+
+Point::Point(double x, double y){
+  this->x = x;
+  this->y = y;
+}
+double Point::getX(){ return this->x; }
+double Point::getY(){ return this->y; }
+\end{lstlisting}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Class Inheritance}
+\begin{itemize}
+\item In C++, subclasses can be created using the following syntax:
+\end{itemize}
+\begin{lstlisting}
+class Parent {
+  ...
+}
+
+// create class Child as a subclass of Parent
+class Child : public Parent {
+  ...
+}
+\end{lstlisting}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{Class Inheritance}
+\begin{itemize}
+\item When defining a subclass, you have access to all public and protected members of the base class
+\item Remember that using private members in the base class means that those members will not be accessible when writing the definitions of the subclass:  it generally makes sense to use protected rather than private when you have inheritance
+\item Class instances of a subclass have access to all public methods and fields in the base class, as well as any additional public members defined in the subclass
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Polymorphism}
+\begin{itemize}
+\item Polymorphism:  ``having multiple forms of one thing''
+\item Polymorphism occurs in classes when we have different method definitions of the same method in parent classes and subclasses -- this is called overriding
+\item Methods of the base class that will be overrided should be marked with the keyword \texttt{virtual}
+\end{itemize}
+\begin{lstlisting}
+class Animal {
+  public:
+    virtual void speak(){ cout << "Roar"; }
+};
+class Dog : public Animal {
+  public:
+    void speak(){ cout << "Woof"; }  // override
+};
+\end{lstlisting}
+\end{frame}
+
+% -----------------------------------------------------
+\section{Generics}
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{Generic Types}
+\begin{itemize}
+\item C++ is statically typed:  we must explicitly state the type of every variable in our code
+\item This includes function return types, function parameter types, and class member field and method types
+\item Sometimes we would like to use generic types so that a function or class can work with multiple different types
+\item In C++ we use the keyword \texttt{template} to implement generics
+\end{itemize}
+\end{frame}
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Generic Functions}
+\begin{itemize}
+\item A generic version of the min function we defined previously would be:
+\end{itemize}
+\begin{lstlisting}
+template <class T>
+T min(T a, T b){
+  if (a < b)
+    return a;
+  return b;
+}
+\end{lstlisting}
+\begin{itemize}
+\item This defines T to be some generic class, and we can then use T as a type in our function definition
+\item The min function can now be called with any type -- T is inferred based on what we pass as arguments
+\end{itemize}
+\end{frame}
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Generic Classes}
+\begin{itemize}
+\item Generic versions of classes work the same way:
+\end{itemize}
+\begin{lstlisting}
+template <class T>
+class Pair {
+  private:
+    T a;
+    T b;
+  
+  public:
+    Pair(T a, T b){
+      this->a = a;
+      this->b = b;
+    }    
+    ... etc.
+};
+\end{lstlisting}
+\begin{itemize}
+\item This defines T to be some generic type, and we can then use T as a type in our function definition
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Instances of Generic Classes}
+\begin{itemize}
+\item Unlike functions, generic types in classes are not inferred
+\item We must explicitly state which type:
+\end{itemize}
+\begin{lstlisting}
+// this is wrong:
+Pair p(3, 3);
+
+// this is correct:
+Pair<int> p(3, 3);
+\end{lstlisting}
+\end{frame}
+
+
+
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{The Standard Template Library (STL)}
+\begin{itemize}
+\item The Standard Template Library (STL) is a subset of the C++ standard library
+\item The STL includes several generic container classes (vector, list, set, queue, deque, etc.)
+\item Also includes algorithms and functions that operate on the containers, as well as iterators that can be used to iterate over the containers
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\section{Memory Management}
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{Memory Management}
+\begin{itemize}
+\item C++ is a lower level language compared to Python or Java with respect to memory management
+\item Memory is not fully abstracted away
+\item C++ allows the programmer to allocate and deallocate memory explicitly, and to access and use the memory locations of variables
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Pointers}
+\begin{itemize}
+\item Pointers are variables that ``point'' to memory locations
+\item Pointers are declared similar to other variables, with a * added to
+the end of the type:
+\end{itemize}
+\begin{lstlisting}
+// this is an integer variable called i
+int i;
+
+// this is an integer pointer variable called j
+int* j;
+
+// this is an Example class pointer variable
+Example* ex;
+\end{lstlisting}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{Referencing and Dereferencing}
+\begin{itemize}
+\item Pointer variables can be dereferenced with * to access their contents
+\item Conversely, a reference to the memory location of a variable can be found with the \& operator
+\end{itemize}
+\begin{center}
+\includegraphics[width=0.9\textwidth]{ptr.png}
+\end{center}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Pointer Example}
+\begin{lstlisting}
+int i = 5;  // int variable i with value 5
+int* j;     // int pointer variable j
+
+j = &i;     // j points to i`s memory address
+*j = 7;     // change the value at address j to 7
+
+std::cout << *j << std::endl;
+std::cout << i << std::endl;
+
+/*  this prints   
+      7
+      7
+*/             
+\end{lstlisting}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Allocating Memory with \texttt{new}}
+\begin{itemize}
+\item When pointers are declared, they initially point to garbage (some random address)
+\item As seen in the previous slides, we can point to addresses of pre-existing variable using \&
+\item Often when using pointers we want to allocate new memory, fill it with something, and point to that:  this is done via the keyword \texttt{new}
+\end{itemize}
+\begin{lstlisting}
+// supposing we have a class Point
+// with constructor that takes x and y values
+Point* p = new Point(3,4);
+
+// new vector from STL with default constructor
+vector<int>* v = new vector<int>();
+\end{lstlisting}
+\end{frame}
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{De-allocating Memory with \texttt{delete}}
+\begin{itemize}
+\item There is no garbage collection in C++
+\item Whenever we allocate new memory using \texttt{new}, we need to deallocate that memory when we are done with it using the keyword \texttt{delete}:
+\end{itemize}
+\begin{lstlisting}
+Vector<int>* v = new Vector<int>();
+
+... at some point later in code ...
+// deallocates memory that was allocated to v
+delete v;  
+\end{lstlisting}
+\begin{itemize}
+\item It is very important to remember to deallocate memory that has been allocated;  failure to do so will lead to ``memory leak''
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{A Note About Class Instances}
+\begin{itemize}
+\item To access members of a class instance, we use dot (.)
+\item To access members of a class instance pointer, we use arrow (->)  -- we've seen this with the \texttt{\bf this} keyword, which is actually a pointer in C++
+\end{itemize}
+\begin{lstlisting}
+MyClass m1 = MyClass();
+MyClass* m2 = new MyClass();
+
+// use dot to access members of m1
+m1.myField;
+m1.myFunction();
+
+// use arrow to access members of m2
+m2->myField;
+m2->myFunction();
+\end{lstlisting}
+\end{frame}
+
+
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{Why Use Pointers?}
+\begin{itemize}
+\item You might wonder:  ``why would we use pointers?''
+\item One reason is to keep variables alive through different scopes:
+\begin{itemize}
+\item The memory associated with variables declared in a certain scope have a lifetime which ends when that scope ends
+\item Declaring a pointer and allocating memory to it with \texttt{new} will keep that memory alive until we \texttt{delete} it
+\end{itemize}
+\item Another reason is efficiency:  
+\begin{itemize}
+\item When we call a function with parameters, the supplied parameters are copied and the copies are used locally in the function
+\item This is very inefficient when we are passing large data structures
+\item We could instead pass a pointer to the structure and all that needs to be copied is the integer memory address
+\end{itemize}
+\end{itemize}
+\end{frame}
+
+
+
+% -----------------------------------------------------
+\section{Exceptions}
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{C++ Exception Handling}
+\begin{itemize}
+\item C++ has a standard library called <exception> that is used for exception handling
+\item Exception handling in C++ is done using a \texttt{try...catch} block:
+\end{itemize}
+\begin{lstlisting}
+try
+{
+  ...some code that might cause exception...
+}
+catch (exception& e)
+{
+  // handle exception here
+  cout << e.what() << endl;
+}
+\end{lstlisting}
+\end{frame}
+
+% -----------------------------------------------------
+\begin{frame}[t, fragile]
+\frametitle{Custom Exceptions}
+\begin{itemize}
+\item We can create custom exceptions in C++ by creating new classes that inherit from the exception class:
+\end{itemize}
+\begin{lstlisting}
+#include <exception>
+using namespace std;
+
+class MyException : public exception {
+  virtual const char* what() const throw()
+  {
+    return "Exception message";
+  }
+}
+\end{lstlisting}
+\begin{itemize}
+\item This exception can then be thrown in code using:
+\end{itemize}
+\begin{lstlisting}
+throw MyException();
+\end{lstlisting}
+\end{frame}
+
+
+% -----------------------------------------------------
+\section{Example}
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{C++ Example}
+\begin{itemize}
+\item An example of A4 from a previous year is given in the src folder
+\item This example gives an MIS and corresponding C++ implementations of each module
+\end{itemize}
+\end{frame}
+
+
+% -----------------------------------------------------
+\section{Additional Resources}
+% -----------------------------------------------------
+\begin{frame}[t]
+\frametitle{Additional Resources}
+\begin{itemize}
+\item \url{www.cplusplus.com/} is excellent
+\item \url{https://stackexchange.com/} for specific questions -- very high chance your question has already been asked and answered there
+\item \href{https://dl.acm.org/citation.cfm?id=2543987}{The C++ Programming Language} by Bjarne Stroustrup (the creator of C++) -- should be able to access via mcmaster library online access
+\end{itemize}
+\end{frame}
+
+
+\end{document}
diff --git a/Tutorials/T07-CppOverview/Slides/ptr.png b/Tutorials/T07-CppOverview/Slides/ptr.png
new file mode 100644
index 0000000000000000000000000000000000000000..59a465e53854d5d857803411960a19543b57b922
Binary files /dev/null and b/Tutorials/T07-CppOverview/Slides/ptr.png differ