Comprehensive Software Development Using C++

This is the first half of a lecture that looks deeper at the First Program we made in the previous section (Hello World).

This is the second half of a video lecture that looks deeper into the Hello World program.

Patricia introduces you to the idea of variables and the various data types that can be stored inside them.

You will learn what the ASCII table is as well as how certain data types are stored and understood by the computer.

An introduction to logic in a manner that will help us relate it to programming.

In this lecture we cover Truth tables and how they can be used to evaluate logical statements. Students will be encouraged to attempt to fill out portions of truth tables.

In this lecture we make a transition from the logic theory to implementing that logic in code via conditional statements. This first part focuses on the "if" statement.

In this continuation of the previous lecture, we finish up with the "if" statement basics and introduce the "else".

In this final part of the conditionals lecture, we introduce the "else if" statement and wrap everything up by showing how it all works together.

In this lecture series we cover the mathematical operators that can be used in C++ programming.

The second part to the Arithmetic Operator lecture.

Students will now learn about computer memory from a high level overview. We will introduce the idea of a container to hold our data.

Arrays will be the most primitive type of container we can use in C++, yet they are very powerful. You will learn how we can group multiple elements of a certain data type into one variable.

Strings are a huge part of all programming languages. In this lecture you will learn the ins and outs of the string data type.

In this lecture we combine our new knowledge of strings with subscripting and conditional statements while we learn more about this useful data type.

See how we can read input from the user and into our program through the command line or console.

Part 2 of the input lecture series goes more in depth while introducing the keyboard buffer and fail bit.

Part 3 of the input lecture series covers cin.clear() and cin.ignore() while we dig deeper into issues that can arise.

In this final part of the input series we cover string input using getline() as well as other string and character related topics.

Practice your skills and solidify your knowledge of Strings/Conditionals/Arrays/Input/Output

We will take our programming to the next level by learning how to create our first loop (the "while" loop).

We continue on with the while loop in this 2nd lecture video.

In this lecture I challenge you to solve a simple problem involving while loops and arrays. We also discuss some additional details about loops and arrays.

Students will now be introduced to another type of loop called the "for loop".

This lecture gives you a chance to put your recently learned for loop knowledge to use by doing some practice challenges.

Students will now be exposed to a new type of programming where we can break chunks of repetitive code into reusable sections.

Why not just put everything in the main function? We will explain why functions can help us write more efficient code.

Students will now have a chance to attempt a practice problem involving functions.

This lecture covers passing arrays to functions and pass-by-reference vs pass-by-value as we revisit an old friend (The ASCII table) and  work through a new solution to the previous problem.

In this last functions lecture we focus on functions calling other functions.

We cover a lot of topics in this lecture as we look at the Virtual Process Memory and introduce you to Pointers.

Building off of the previous slideshow, we now head to the editor to show you how to use pointers and dynamically allocated variables in your code.

This lecture shows you how to pass pointers to functions as well as how to pass a variable by address.

This lecture focuses on returning pointers from functions.

This lecture shows you how to create dynamically allocated arrays.

In this lecture, students will learn how to use loops inside of other loops.

It's time to introduce multi-dimensional arrays. Yes, you can have an array of arrays that functions like a matrix!

We can dynamically allocate 2d Arrays as well!

We continue where we left off with the last program and discuss how to format the output with the iomanip library.

Time for your first project! For this first project you will have a video lecture explaining the project details and instructions. Subsequent projects will mainly be listed as assignments with written instructions. Please do not look at the solution resource until you have exhausted all possible attempts you have in you to solve it for yourself!

We now look into reading and writing data to and from files rather than just the console.

In this long video lecture, we discuss how to send arguments to your program when you run it from the command line.

Exceptions are a feature of many programming languages. In this video we come up with a trivial example, but you will encounter code at some point that might throw a runtime error and you will want your program to attempt to run that code and then handle the error in a way of your choosing with an error message of your choosing.

Students will now learn about a powerful container called a vector. Vectors are like fancy arrays!

This video picks up where we left off when the last vector program resulted in a segmentation fault. We continue to discuss vectors and the member-functions/methods that you can call on them to perform special actions or get information about the vector.

In this short lecture we describe a programming challenge for you to solve. In the next few lectures we will discuss different solutions to this type of challenge. (Unless you are already familiar with sorts, it is best to refrain from looking up sorting algorithms before you attempt this challenge)

BubbleSort is one of the most simple sorting algorithms, but it is still quite interesting. This is the first of 2 basic sorting algorithms we will discuss in this section of the course.

In this lecture, we try to make our BubbleSort algorithm a little bit more efficient by making some small changes to our code.

We now focus on another simple sorting algorithm to gain a better understanding of the diversity of algorithms.

In this short lecture we challenge the students to come up with a simple searching algorithm.

This lecture will introduce a very simple sorting algorithm known as Linear-Search or Sequential-Search.

For the 2nd and final searching algorithm, we introduce the very efficient Binary Search.

This lecture shows students how to use a graphical debugger. More specifically, we cover the usage of the CLion IDE Debugger.

This portion of the debugging lecture shows you the basics of navigating the GNU Debugger. The GNU Debugger is a popular command line debugging tool.

Once again we transition to a new style of programming. This is the beginning of us being able to create our own data types. The struct data type is introduced in this lecture.

In this lecture students will be further exposed to the features of and the ways to use the struct data type.

In this continuation of the previous lecture, we wrap up the struct data type.

A introduction to what OOP is, and how we use it when we write C++ code.

We now head to the editor to implement some classes in code, instantiate an object and introduce the idea of a constructor.

In this lecture we introduce the use of the "const" keyword with member functions as we continue to practice OOP using our Car class.

This lecture exposes students to the potential to use multiple files for their classes by splitting the code into separate header and implementation files.

In this video we show you how to add nifty function to your class that allows you to make copies of your class' objects. We also look at a special type of pointer to dynamic memory that deallocates itself!

On this quick tangent, we use a more simple example to explain the usage of std::shared_ptr vs std::unique_ptr and very briefly discuss std::weak_ptr.

Students will now learn about how to use operators with objects as operands. This video starts with an introduction into overloaded operators with our first example being the overloaded assignment operator.

In this lecture we go over the overloaded Addition and Subtraction Operators.

This video focuses on the overloading of the "==" equality operator.

We can even overload the "<<" and ">>" operators as is shown in this lecture.

This video lecture introduces a big new topic. We will discuss how to use the Unified Modeling Language to model our program design as we transition to the topic of inheritance. The video lecture is quite long so you might want to put Note markers and take some breaks.

We now look at the access ordering of base and derived classes as we discuss the meaning of the private/protected/public keywords as they pertain to inheritance.

This video introduces another important part of Object Oriented Programming that allows us to have a better overall design.

This lecture introduces the idea of an Abstract Base Class and switching virtual functions to pure virtual functions.

In this new topic we show students how templates can be used to make functions accept arbitrary data types as arguments/parameters. At the end of the video we offer up a little challenge to finish what we have started in the lecture.

We will now go over the previous task of finishing out the Function Templates and will talk about why some of you may have experienced issues when trying to add a Function Template to the base class virtual functions.

You might have already asked yourself this and the answer is YES, you can use templates for classes as well!

We start our DS/Algo journey by looking at the industry standard method of measuring the runtime and space efficiency of code.

Our first major Data Structure is discussed in this lecture. Linked Lists could be considered the basis for most all of the ADT data structures as they are often the simplest example of chaining together pointers.

We head to the editor to implement our Linked List in code.

In this lecture we add class templates to our Linked List. If you are unfamiliar with class templates or a little rusty, go check out the class templates lecture in the previous section of the course.

In this lecture we modify our Linked List and turn it from a Singly Linked List into a Doubly Linked List where we can traverse forwards and backwards.

In this video we go over a potential solution for the Destructor and Palindrome challenge.

In this video lecture, we modify the append function to stop it from pointlessly traversing, and we add an insertion function after discussing the theory and how it differs from the append function.

This is a video solution to the Linked List Challenge 2 delete problem.

We cover a variation of a new Data Structure called a "Hash Table" that will put our Linked Lists to use. This lesson is all Theory for the next Project which will put your Linked List skills to the test.

Recursion is often a very confusing topic for students. In this lecture we demystify this tricky subject and show you what goes on behind the scenes of a recursive function.

We introduce the famous Binary Search Tree. A data structure that can help you store data in a way that allows for very efficient look up operations.

We continue adding functionality to our Binary Search Tree in this lecture.

We focus in on a tricky algorithm in this lecture. It is a good opportunity for us to learn more about BST's and recursion simultaneously as we traverse the data structure looking for the k-th smallest value. This lecture is both theory and practical implementation.

The AVL tree is a more efficient version of the Binary Search Tree. In this lecture we discuss why it is better and how it works.

We now move to the practical implementation of the AVL tree. We set up a class and a couple of functions.

In this lecture we start implementing our local insert member function for the AVL tree class, writing the necessary code to check for different imbalances.

In this video we walk through the function implementations for all of the AVL Tree rotations (LL, LR, RR, RL).

In this final AVL Tree lecture, we prove our AVL tree works by writing a function that prints the tree in order of values (The function should be called "inOrderDump()" but I mistakenly call it "levelOrderDump()" in the video). We also walk through a visualization of the tree being built and the rotations that should be made before comparing the final result to the output of our function.

Heaps are simple yet powerful data structures that help us keep track of maximum or minimum values.

This lecture covers the heap's delete operation and heapify process.

This final Heap lecture looks at how to transform an array of values into a heap. After this video I recommend attempting to Implement a heap as an Abstract Data Type. Since it is just an Array with some interesting properties, it really just comes down to you implementing the Heapify algorithm correctly. This algorithm can be done recursively or iteratively. I have attached a resource that covers the analysis of the Heapify algorithm.

We need to introduce some new data structures before moving on to the next section. In this video we discuss the Stack and Queue data structures. (We will be using the STL containers for these data structures).

In this lecture we go over the Stack and Queue from the Standard Template Library.

This lecture marks the start of a new subsection where we will discuss graph algorithms (An integral part of computer science as many important problems can be solved using graphs).

Depth First Search (DFS) is a very common and useful graph traversal algorithm. In this lecture we go over the theory of DFS.

In this video lecture we take a detailed look at the code behind graphs and depth first search. After writing the necessary code to demo the algorithm, we trace through an example with an animation.

We will put our new graph and DFS knowledge to use by leveling up and learning about Topological Sort and its applications.

This is the project 6 solution video.

Breadth First Search (BFS) is another popular algorithm that tries to explore outward to to neighbors initially rather than going deep like DFS. In this lecture we will go over the theory behind BFS.

Now we write the code for the BFS algorithm.

To do more formal Analyses of Algorithms, we will need to look a bit deeper into bounds and notation.

To do more formal Analyses we will also need to use a bit of math. In this lecture we go over using summations to show the time complexity of small basic snippets of code. (NOTE: There will most likely be a big divide in the math level of students that take this course. Because of this I assume that summations are not known and so I give a brief explanation. This course is not meant to dive deep into mathematics, so I try to keep things as simple as possible)

To formally analyze recursive algorithms, we will need to look into a new topic called a "Recurrence Relation". I have attached an extra resource to this lesson with a Recurrence solution that includes a sum just incase you would like to look at another example.

We use a recursive version of Binary Search to learn how to solve recurrences that involve division of the input size. This lecture will provide an explanation of the recursive binary search algorithm as well.

We look at how something called the smoothness rule can help us solve a version of the previous recurrence that uses floor division.

This video serves as a brief introduction to a new topic in which we will talk about different algorithmic design strategies that are used for optimization problems.

We now introduce the popular algorithmic design technique known as "Dynamic Programming" by using it with a classic example that we have already seen once so far in this section of the course.

In this video we look at using a technique called the "Greedy Method" to solve the problem of giving the optimal amount of change.

We see the true power of Dynamic Programming in this lecture where we come up with a better solution to the coin change problem.

We now head to the editor to go over the Dynamic Programming implementation of the coin change problem. NOTE: I mistakenly named my CLion project "CoinRow" when I really meant "CoinChange" (The CoinRow problem is a different problem).

The 01 knapsack problem is an interesting optimization problem that will let us further compare our recently learned algorithm design strategies.

We are now ready to head to the IDE/editor to go over how to implement the Dynamic Programming solution to the 01 Knapsack problem in code.

In this final lecture. I offer some (take it or leave it) advice and opinions on potential next steps for students with different backgrounds and goals. Thank you so much for taking this course and I wish you the best in your future endeavors!