Learn C++ Programming by Making Games

I'll explain how the human brain infers and bridges unrelated logic

I'll explain how to break down problems into a series of small understandable steps concrete enough

Explain that you should solve the problem first and then translate the code

We go over a very important concept called pseudo code. It's a way of combining english statements with our formal language. Use this when you don't know the next piece of C++ code you need to write. Write pseudo code instead to solve the problem.

I'll show you how we will be practicing throughout the course. I'll always practice with you in these videos so you can see how I solve the problems. It's important for you to practice on your own as well afterwords.

I go over setting up MinGW on windows. This is a necessary step in order to run our programs.

I go over how to setup GCC on Mac OSX. This is a necessary step in order to run our programs on Mac.

I go over how to setup GCC on Linux. This is a necessary step in order to run our programs on Linux.

We go over the underlying representation of the types and their sizes in memory. 

I go over the math type operations you can use with the variables we've gone over. 

We go over standard input so we can read values from the console. This will allow us to make more interesting programs.

I go over briefly what the compiler and linker are and why they are important in C++.

I go over constants and why they are useful in our programs.

We do some practice for our basic programs. This will reinforce our understanding of variables, input and output.

A quick lecture to go over what statement blocks are. 

We go over boolean logic and why it's useful. We use boolean logic in our programs to make decisions hence all boolean expressions evaluate to true or false.

We go over conditional expressions which manipulate boolean variables and boolean expressions. 

If statements change the flow of execution of our programs. Based on a boolean expression, our if statement will execute one case of our if statement but not the other. 

Switch statements are similar to our if statements but differ in a few important ways. It's another way we can choose the path of execution of our programs.

One more way we can make decisions in our programs. 

We do some practice with if statements and switch statements. 

We look at how to do the same code many times. This is called looping and it's one of the most fundamental things a program can do. We'll be able to make more interesting programs using this.

We look at another looping structure that is similar to while loops but differ in an important way.

We look at one of the most important looping structures, the for loop, For loops are a great way of counting. 

We look at 2 ways we can change the flow of our loops the break statement and the continue statement.

We briefly look at nested loops and why they are useful.

We see how loops can affect our input that we learned about before. We use loops to let the user try again if they input something incorrectly.

We do some practice with loops and see some more interesting problems.

We go over not only an important concept in programming, but an important concept for designing our programs. We'll be using functions to great effect when making our games.

Scope is the concept that tells us where we can use our variables. 

Lifetime is the concept that tells us when our variables are valid to use. 

We go over how to pass variables into functions so the functions can use them in its calculations.

We go over how to return values from our functions.

We go over how function signatures can be used in order to make existing functions seem like they can do more things.

We go over default parameters and how to use them.

We go over another way to loop using function calls.

We do some practice with functions together.

Finally a game! This game will encompass everything we've done up until this point. We go over how to understand the problem and start understanding each part that will be important.

We break down the program into smaller sections and use our pseudo code to start breaking down the implementation into steps we as humans can understand. 

Once we've understood the problem and broken it down into steps we understand, now is the time to implement it. 

We go over one more thing to add in our game, random numbers.

We go over a mental model of how to view memory. This will help us understand the next lecture better.

We go over one of the most important features of C++, the pointer. Pointers are variables that point to memory address. They can directly affect the variables using what's called dereferencing. 

We go over a similar concept to pointers called references.

I show you how const can affect pointers. 

I go over the difference between pass by reference and pass by value. Pass by reference will change the original variable passed in. Pass by value makes a separate copy of the value.

I'll go over some things to avoid when using pointers.

I go over a simple example of using references.

We go over a very useful topic called arrays. Arrays are way for us to store a sequence of variables contiguously in memory. 

We go over the similarities and differences between pointers and arrays. 

When passing arrays to functions, it's always passing by reference meaning we always change the original array.

We go over how we can use arrays to make a string of characters. I go over the difference between CStrings and character arrays.

We do some practice with arrays and cstrings.

I go over the difference between stack memory which is what we've been using up until this point and dynamic memory. Dynamic memory's lifetime is the lifetime of the program once it's allocated. We as programmers choose when to delete it.

I go over how to use new and delete with arrays.

I go over how to properly use pointers with dynamic memory. There are many things that can go wrong and we need to good way to remember how to use it properly.

We go over some problems that can happen when using dynamic memory.

We do some practice with dynamic memory.