Learn C++ Programming By Making Games

What's inside

Learning objectives

Understand how to break down problems into smaller easier to understand tasks
Take those tasks and translate them into c++ code

You'll be able to make small but fairly complex ascii games

Understand how to break down problems into smaller easier to understand tasks
Take those tasks and translate them into c++ code
You'll be able to make small but fairly complex ascii games

Syllabus

You'll understand what this course is about and how we'll go about it

Introduction

You'll understand how to break down problems into small parts

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

I'll explain what programming is and isn't.

Explain what algorithms are.

Explain data.

Show drawing of the Transform

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.

I go over how to setup Eclipse C++ and we make our first program. I'll go over a little bit of how everything works. Don't worry about not understanding everything yet. We'll be doing a lot more examples.

We go over what variables are and how to create then and set their values C++. We go over just the built in types like int, float and char.

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.

We go over a way of breaking down our problems call top down design. Top down design helps us abstract big steps of our programs into function. We then break those steps down into smaller steps and repeat the process. We do this until we have concrete steps that we can implement in our programs.

We go over Hangman and try to understand everything about it in order to break down the problem.

We to the Top Down Design of Hangman in order to get things ready for the implementation.

Part 1 of the implementation of Hangman. We setup the game and start to get things drawing and acting correctly.

We finish the major implementation of our Hangman game. Everything will be working by the end of this lecture.

I go over how to use multiple files in C++. We do this in order to start making a little library of functions that we can use in our other projects.

I'll show you how to setup Eclipse such that you can run our programs in your Operating System's console. We need this in order to achieve certain effects that we use in our games.

There's a mistake in the video. When setting up for windows I wrote:

-static-libcc -static-libstdc++

It should be:

-static-libgcc -static-libstdc++

Thanks to Jesse Osanu for pointing that out!

Career center

Learners who complete Learn C++ Programming By Making Games will develop knowledge and skills that may be useful to these careers:

Game Programmer

A Game Programmer brings interactive experiences to life by writing the code that powers game mechanics, systems, and functionality. This course, "Learn C++ Programming By Making Games," provides an exceptional foundation for aspiring Game Programmers. It immerses learners in C++, the pivotal language for professional game development, through a practical, project-based approach. The course's focus on deconstructing problems using pseudo code and mental models directly mirrors real-world game development challenges, enabling efficient translation of design concepts into code. Specifics like understanding low-level memory with pointers and dynamic memory, along with mastering core programming constructs like loops and functions, are indispensable for developing high-performance game logic. By making actual games such as "The Game Of Eight" and "Hangman," learners gain tangible experience, solidifying techniques necessary for a successful career in game programming.

See salaries and explore the career path for Game Programmer

Gameplay Programmer

A Gameplay Programmer focuses on implementing core game mechanics, player interactions, and artificial intelligence, transforming design documents into interactive experiences. This course lays a strong foundation for a career as a Gameplay Programmer by focusing on problem-solving through C++. The curriculum teaches how to break down complex gameplay ideas into programmable tasks, leveraging pseudo code and mental models to structure solutions. Learners will gain proficiency in fundamental C++ concepts like conditional expressions, loops, and functions, which are crucial for creating engaging game states and behaviors. The practical experience of building beginner game projects, including "The Game Of Eight" and "Hangman," provides direct exposure to the challenges of scripting game logic. Understanding how to manage data with arrays and handle memory with pointers ensures that aspiring Gameplay Programmers can write clean, performant code, essential for fluid and responsive gameplay.

See salaries and explore the career path for Gameplay Programmer

Engine Programmer

An Engine Programmer develops and maintains the core software infrastructure that a game runs on, including rendering, physics, and resource management. This course is highly relevant for individuals aiming to become an Engine Programmer, particularly with its deep dive into low-level C++ concepts. The curriculum emphasizes understanding how things really work on the computer, covering memory representation, pointers, references, and dynamic memory management. These are critical skills for optimizing performance and building robust engine systems. Learners will practice problem decomposition and translating complex requirements into efficient C++ code. The course’s use of C++ and its focus on fundamental programming principles, coupled with insights into problem-solving mental models, helps prepare individuals to tackle the intricate challenges of engine development. While the course makes beginner games, the underlying C++ and systems knowledge acquired is invaluable for progressing into engine-level programming.

See salaries and explore the career path for Engine Programmer

Tools Programmer

A Tools Programmer creates applications and utilities that streamline the game development process for artists, designers, and other programmers. This course offers a solid grounding for an individual interested in becoming a Tools Programmer by enhancing their C++ programming and problem-solving skills. The emphasis on breaking down problems into understandable tasks, using pseudo code, and then translating them into C++ code is directly applicable to designing user-friendly and efficient development tools. Learners gain proficiency in core C++ constructs like functions, arrays, and standard input/output, which are essential for building interactive command-line utilities or graphical interfaces for tools. The course also details setting up programming environments and understanding compilers, providing useful context for integrating tools into a development pipeline. Although focused on games, the structured approach to programming and practical application of C++ principles can be leveraged to create effective and reliable development tools.

See salaries and explore the career path for Tools Programmer

Graphics Programmer

A Graphics Programmer specializes in rendering visual elements, creating the stunning worlds and characters seen in games and simulations. This course can establish a crucial foundation for aspiring Graphics Programmers by teaching the essential C++ language and low-level system understanding. The curriculum’s focus on how things really work on the computer, including memory models, pointers, and dynamic memory, is fundamental for understanding how graphics data is organized and processed efficiently. Learners develop strong problem-solving skills, breaking down complex visual algorithms into achievable C++ code, which is vital in graphics development. Proficiency in C++ control flow, functions, and arrays are indispensable for implementing rendering pipelines and managing graphical resources. While not directly teaching graphics APIs, the robust C++ foundation, coupled with the ability to build game projects, develops the logical thinking and coding discipline necessary to transition into specialized graphics programming.

See salaries and explore the career path for Graphics Programmer

Software Engineer

A Software Engineer designs, develops, and maintains software applications and systems across various industries. This course provides a strong entry point for individuals pursuing a career as a Software Engineer through its comprehensive approach to C++ programming and structured problem-solving. The emphasis on breaking down problems, using pseudo code, and translating logic into C++ code establishes a robust foundation in algorithmic thinking and software design principles. Learners gain hands-on experience with fundamental programming concepts such as variables, data types, conditional logic, loops, functions, and data structures like arrays. Crucially, the course delves into low-level memory management with pointers and dynamic memory, skills highly valued in performance-critical software development. While the course uses game projects as a practical application, the core C++ language proficiency and the mental models for tackling programming challenges are broadly applicable across all domains of software engineering.

See salaries and explore the career path for Software Engineer

Embedded Systems Engineer

An Embedded Systems Engineer designs and develops software for specialized computer systems found within larger devices, from smart appliances to industrial controls. This course offers highly relevant skills for an aspiring Embedded Systems Engineer, particularly given its deep exploration of C++ and low-level computing concepts. The curriculum focuses on understanding how things really work on the computer, including detailed explanations of memory representation, pointers, references, and dynamic memory management. These areas are absolutely critical for interacting directly with hardware and optimizing code for resource-constrained environments. Learners practice breaking down problems into concrete steps and translating them into efficient C++ code. The course's approach to fundamental programming principles, coupled with a strong grasp of C++ syntax and logic, helps build the foundational competence required to program microcontrollers and other embedded devices where performance and memory control are paramount.

See salaries and explore the career path for Embedded Systems Engineer

Firmware Engineer

A Firmware Engineer develops the permanent software that controls specific hardware devices, bridging the gap between hardware and high-level software. This course can be highly valuable for anyone aspiring to become a Firmware Engineer, due to its strong emphasis on C++ and low-level memory operations. The curriculum directly addresses how to think about programming and solving problems, which is essential for working with constrained hardware resources. Learners will understand the underlying representation of data types and their sizes in memory, along with mastering pointers, references, and dynamic memory. These C++ features are indispensable for precise control over hardware and writing efficient, optimized code. The course's focus on structured problem-solving and translating logic into C++ provides a practical framework for developing robust firmware for various devices. While the course projects are game-oriented, the core C++ skills and deep understanding of memory management are directly transferable to firmware development.

See salaries and explore the career path for Firmware Engineer

Robotics Programmer

A Robotics Programmer develops software that controls robotic systems, from low-level motor commands to complex navigation and task execution. This course may be useful for an aspiring Robotics Programmer, providing a deep foundation in C++, a language extensively used in robotics for performance and control. The curriculum's focus on understanding how things really work on the computer, including memory models, pointers, and dynamic memory, is crucial for interacting with hardware and optimizing real-time robotic operations. Learners develop strong problem-solving skills, breaking down complex robotic behaviors into manageable C++ tasks. The course's emphasis on control flow, functions, and arrays helps build the logical and structural programming abilities necessary for developing robust robotic software. While the projects are game-based, the core C++ mastery and low-level system understanding are highly transferable to the intricate programming challenges in robotics.

See salaries and explore the career path for Robotics Programmer

Systems Programmer

A Systems Programmer builds and maintains low-level software that manages computer hardware and system resources, such as operating systems, device drivers, or utilities. This course is very beneficial for individuals interested in becoming a Systems Programmer, offering a robust foundation in C++ and crucial low-level concepts. The curriculum provides detailed insight into how things really work on the computer, covering memory models, pointers, references, and dynamic memory management. These are fundamental for writing efficient and reliable system-level code. Learners are taught to break down complex problems and translate them into precise C++ solutions, a skill vital for developing robust system components. Understanding the compiler and linker, as covered in the course, also provides essential context for building and debugging system programs. The focus on C++ data structures like arrays and control flow mechanisms helps develop the analytical and coding rigor required for this challenging field.

See salaries and explore the career path for Systems Programmer

Compiler Engineer

A Compiler Engineer designs, develops, and optimizes compilers, which translate source code written in one programming language into another. This course may be useful for an aspiring Compiler Engineer, as it provides a strong practical foundation in C++ and a fundamental understanding of how programs are processed. The curriculum explicitly covers what the compiler and linker are and why they are important in C++, offering direct relevance to the field. Learners gain a deep understanding of core C++ programming concepts, data structures like arrays, and memory management with pointers and dynamic memory. The course's emphasis on low-level computer operations and mental models for problem-solving helps build the analytical skills necessary to comprehend the intricate processes of language parsing, code generation, and optimization. While the course focuses on using C++ for game development, the thorough grasp of the language and compilation process is highly beneficial. This role often requires an advanced degree.

See salaries and explore the career path for Compiler Engineer

Backend Developer

A Backend Developer builds and maintains the server-side logic, databases, and APIs that power websites and applications. This course may be useful for an aspiring Backend Developer, particularly for roles requiring high-performance systems where C++ is often utilized. The course instills strong problem-solving methodologies, teaching learners to break down complex tasks and implement them efficiently using C++. Proficiency in core programming concepts such as algorithms, data structures like arrays, functions, and control flow is essential for building scalable and robust backend services. The understanding of memory management, including pointers and dynamic memory, can be particularly advantageous in optimizing server performance and resource utilization. While the course focuses on game development, the underlying principles of structured programming, logical thinking, and C++ language mastery are directly transferable to designing and implementing powerful backend solutions.

See salaries and explore the career path for Backend Developer

Application Developer

An Application Developer designs, builds, and maintains software applications for various platforms, from desktop to enterprise systems. This course may be helpful for an aspiring Application Developer by imparting a strong foundation in C++ programming and problem-solving. The curriculum teaches how to deconstruct complex application requirements into manageable tasks and translate them into efficient C++ code using methodologies such as pseudo code. Learners gain comprehensive knowledge of core programming constructs including variables, conditional logic, loops, and functions, which are universally applicable in application development. The course also introduces data structures like arrays and concepts of memory management, providing a deeper understanding of how applications interact with computer resources. While the course uses game development as its application context, the rigorous C++ training and emphasis on fundamental programming principles are broadly valuable for creating diverse application software.

See salaries and explore the career path for Application Developer

Quantitative Analyst Developer

A Quantitative Analyst Developer typically works in finance, creating and implementing complex mathematical models and algorithms for trading strategies or risk management. This course may be useful for aspiring Quantitative Analyst Developers, especially those seeking to build a strong foundation in C++, a language favored for its performance in financial computing. The course's emphasis on breaking down problems, understanding algorithms, and translating logic into efficient C++ code is highly relevant for implementing intricate quantitative models. Learners develop robust skills in core programming principles, data manipulation, and memory management with pointers, which are critical for optimizing computational efficiency. While the course focuses on games, the rigorous training in C++ programming, problem-solving mental models, and understanding of low-level computer operations helps lay the groundwork for tackling the demanding analytical and computational challenges of a Quantitative Analyst Developer role. This role often requires an advanced degree.

See salaries and explore the career path for Quantitative Analyst Developer

Algorithm Engineer

An Algorithm Engineer designs, analyzes, and implements efficient algorithms to solve complex computational problems across various domains like data science, machine learning, or optimization. This course may be helpful for an aspiring Algorithm Engineer by building a strong command of C++ and foundational algorithmic thinking. The curriculum explicitly covers what algorithms are and emphasizes breaking down problems into smaller, understandable steps using pseudo code before translating them into C++ code. Learners gain proficiency in core programming constructs, understanding data structures like arrays, and managing memory effectively, all crucial for designing and optimizing algorithms. The detailed mental models for problem-solving and the practical application of C++ in game projects provide a solid base for understanding how to approach and implement complex computational logic. This role often requires an advanced degree.

See salaries and explore the career path for Algorithm Engineer