This video takes you through the history of software engineering and gives an idea of what to expect from the field of software engineering.
Here we overview the basic structure of a C++ program. The idea is to give you a general idea of the basic constructs you're going to see when you start programming.
In this video we focus on the process of compiling a CPP file, turning it into an executable program that can be run by an end user.
If you're a Mac user, this video will be helpful for getting started with Xcode, an IDE that you can use to write your own C++ code.
For Windows users, this video provides an introduction to coding with Visual Studio, showing you how to set up a C++ project.
This video covers the various data types that you can use in C++, and also takes a look at how each data type is handled within the computer's memory.
This video focuses on how integers are stored in binary, discussing how bases work, and how to convert binary to decimal, and how memory works with binary information.
In this lesson we drive home the previous video topics by focusing on the world of input/output (IO) and working with data by storing it and taking it from user inputs.
Moving on with the Software Engineering series, we now move on to take a look at decision making in your programs, also known as branching, by using "if" statements.
In this video we look at looping, which allows you to execute a specific portion of your code a set number of times, rather than having to repeat the same lines over and over.
We now take a look at the concept or arrays and how they can be used to store groups of data. You'll also see how memory deals with arrays, and special C++ considerations.
In this video we look at functions, which are blocks of code which can be called upon as a single command. See how they can be used inside your programs.
Header files allow you an easy method to reuse code throughout your program. Here, we look at standard header file syntax and how to avoid some common pitfalls.
Pointers are a topic that can often puzzle new programmers. In this video we describe what pointers are and how they are handled within memory.
Continuing with our lecture on pointers, we now go (much) deeper in depth into how you can make use of your own pointers in code.
This video takes a look at C-style strings in C++, what they are, how to use them, and some of the common pitfalls you should avoid.
We now move on to user-defined data types, which allow you to store and manipulate your own types of data.
This video provides an introductory look at linked lists, which allow you to store an arbitrary number of custom items, without the constraints of an array.
Continuing with our discussion of linked lists, we take a look at how we can make our lists more efficient by no longer requiring so much maintenence by the programmer.
Here we wrap up our section on linked lists, covering how we can delete items from our lists and how to manage the deletion process.
We now begin our foray into the world of object-oriented programming! This video focuses on key definitions and terminology you'll run into in OOP.
With a basic understanding of the key principles behind OOP, we now put those principles into practice by recreating our linked list using OOP.
Continuing with our explanation of OOP, we now take a look at one of the most important aspects of it: inheritance. We also cover virtual methods.
This video takes a look at stacks, how to create them, and how data is manipulated as it moves into and out of the stack.
This video concludes our discussion of inheritance by discussing the concepts of multiple inheritance, abstract classes, and interfaces.
This brief introduction discusses where the next leg of the series is headed, covering a few of the key principles behind algorithms.
The first problem that we will approach as we learn algorithms is a search. This video covers the concept of recursion as a search method.
Leveraging on the recursion concepts addressed in the previous video, we now put theory into practice by developing a binary search.
In this video take a look at a new problem, introducing you to the Towers of Hanoi game, and how we can create an algorithm to solve it.
This video covers a solution for the Towers of Hanoi problem, walking you through the entire code and showing you how the solution works.
This video begins a look at sorting algorithms. For this first lesson, we take a look at a very simple example, the bubble sort.
Moving on with sorting algorithms, we now take a look at selection sort, which has many of the same performance characeristic as bubble sort.
The next sorting algorithm we will look at is insertion sort, which can be extremely useful for sorting smaller sets of data.
Here we take a look at the Merge sort algorithm, which will be the fastest and most efficient sorting algorithm we've used so far.
This last video over sorting algorithms focuses on Quicksort, which can sort in-place and uses no additional memory.
In this video we introduce you to the concept of graphs, what they are, and how they are handled in the computer.
Moving on, we now demonstrate the process of implementing a graph in a simple C++ demonstration program.
Now that you've seen a straightforward implementation of a graph, we take a look at a more elegant solution that requires less management and implements weights.
Here, we finish up the implementation of our improved graph, adding in the code to implement an adjacency list.
This video explores the problem of finding the shortest path between two nodes. To do this, we will make use of Dijkstra's algorithm.
Now that we have explored Dijkstra's shortest path algorithm, we implement it into our code and use it to find the shortest path between nodes in our graph.
In this video we move on to the subject of trees, which are a type of graph that utilizes a hierarchical structure.
This video goes into more depth on the subject of trees, explaining how they work under the hood and demonstrating the creation of a calculation system.
In this video we begin coding up the implementation of the tree system that we explored earlier.
This video continues with the expression tree started previously, adding in the remaining functions to get the expression tree working.
This short correctional video cleans up a memory leak that remained from the code written in Video 45.
This video includes a quick review of the Software so far, as well as a quick overview of the topics covered throughout the next project, a tic-tac-toe game using OpenGL.
We now discuss the overall design and rules of our tic-tac-toe game. The idea here is to deliver an overview of an on-the-fly design session via whiteboard.
With our design behind us, we can now move on to the setup of the project. This video also includes an introduction to Git, a distributed source control system.
For starters, we begin setting up our XCode project files and getting them associated properly in Git for source control.
Now that the XCode project setup is complete, we can begin the Visual Studio side of the setup, completing our plan for Mac and Windows cross-platform design.
It’s finally time for us to start coding out our classes, beginning with the game engine class that was laid out in our design whiteboarding lesson.