Learn C++ Game Development

C++ game development course for beginners.
  • Lectures 43
  • Video 5 Hours
  • Skill level beginner level
  • Languages English
  • Includes Lifetime access
    30 day money back guarantee!
    Available on iOS and Android
    Certificate of Completion

How taking a course works

Discover

Find online courses made by experts from around the world.

Learn

Take your courses with you and learn anywhere, anytime.

Master

Learn and practice real-world skills and achieve your goals.

Course Description

Learn C++ game development is a course I made for everyone who knows how to program, but doesn't know where to start with game development. The course teaches you how to use the SFML library for C++, to start working with graphics, events and sound to create a 2D game. Everything is done step by step with the help of videos, so it's easy to follow along and learn. At the end of the course you will know what you need for game programming and will be able to start making your own games.

Warning: This course was published more than 2 years ago and the technology used in it progresses fast. The current most updated version of SFML (2.1) doesn't work out of the box with Visual Studio 2013 (or the express editions) and it requires more work to setup. If you want to follow this course easily, then you should use the 2012 or older version of Visual Studio (or the express edition) which can still be officially downloaded from Microsoft site.

What am I going to get from this course?

  • Over 43 lectures and 4 hours of content!

What you get with this course?

Not for you? No problem.
30 day money back guarantee

Forever yours.
Lifetime access

Learn on the go.
Desktop, iOS and Android

Get rewarded.
Certificate of completion

Curriculum

02:34

A welcome video where I explain what you need for the course, what you will learn and how it's going to progress.

Section 1: Lesson 1: Setup
12:55

A new video, where I will show you how to prepare you environment, so you can continue with the course using the latest Visual Studio 2013 and SFML 2.1. You can skip lecture "Installing Visual C++" and "Installing SFML" if you use this video.

Made because there were many questions on how to use the latest software with this course.

The microphone quality is a little bad and some words are muffled, but I hope this video will help everyone out there.

07:23

In this video I show how to install Visual C++ Express 2010.

Link to the site:

http://www.microsoft.com/visualstudio/en-us/products/2010-editions/visual-cpp-express

09:27

In this video I show how to prepare te library SFML to use it with Visual C++.


Link for the download:

http://www.sfml-dev.org/download/2.0-rc/SFML-2.0-rc-windows-32-vc2010.zip

Section 2: Lesson 2: The window
11:45

In this video I show you how to create the project in Visual C++.

08:06

In this video I show you how to create a simple window for the game.

07:24

in this video I show you how the basic game loop is constructed.

1.29 MB

If you want you can download the file, extract it and then open the solution with Visual C++ Express.

Section 3: Lesson 3: Events
09:59

In this video I show and explain to you how to use keyboard events in SFML.

11:41

In this video I show and explain to you how we can use a state based system to separate events from logic.

1.29 MB

If you wish you can download, extract and open the file to see how the project should look like by now.

11:34

In this video I show and explain to you how we can use mouse events for our game.


NOTE:

There is a faulty line of code:

int mouseX, mouseY;

Replace it with:

int mouseX = 0, mouseY = 0;
1.29 MB

If you wish you can download, extract and open the file to see how the project should look like by now.

Text
Here are some exercises for "Lesson 3: Events". These exercises will test if you understood how to use events and separate events from logic. The exercises go from the easiest to the hardest, but are all solvable with some logical thinking. After you finished the exercises or if you don't know one y…
12:58

In this video I show you the solutions for the exercises.

Section 4: Lesson 4: Drawing or rendering
15:32

In this video I show and explain to you how to draw simple shapes like a rectangle and a circle.

1.29 MB

If you wish you can download, extract and open the file to see how the project should look like by now.

09:31

In this video I show and explain to you how to create a simple image, load it and render it in the game.

Link to GIMP website:

http://www.gimp.org/

03:57

In this video I show and explain to you how to find an image and then prepare it for use in the game.

Link to OpenClipArt website:

http://openclipart.org/

1.64 MB

If you wish you can download, extract and open the file to see how the project should look like by now.

07:54

In this video I show and explain to you how to load and render fonts in the game.

I have gotten a notice so I will post this here. If you are planning on releasing your games in the future, then don't use Microsoft fonts, but find some free and open sourced ones on the web. They are really easy to find, and you can avoid licensing problems.

2.05 MB

If you wish you can download, extract and open the file to see how the project should look like by now.

Section 5: Lesson 5: Sounds and music
03:59

In this video I show and explain to you how to prepare the project in order to be able to use sounds and music in the game.

07:06

In this video I show and explain to you how to create a simple sound using a website and then load and play it in the game.

Link to site:

http://www.bfxr.net/

2.72 MB

If you wish you can download, extract and open the file to see how the project should look like by now.

05:10

In this video I show and explain to you how to find and prepare music to load and play it in the game.

Websites:

http://www.jamendo.com/en

http://media.io/

2.78 MB

If you wish you can download, extract and open the file to see how the project should look like by now.

Section 6: Lesson 6: Game mechanics
09:32

In this video I show and explain to you how to use what we have learned till now to create some simple game logic.

2.66 MB

If you wish you can download, extract and open the file to see how the project should look like by now.

12:42

In this video I show and explain to you how to create simple movement with events and rendering.

2.66 MB

If you wish you can download, extract and open the file to see how the project should look like by now.

08:59

In this video I show and explain to you how basic collision works.

2.66 MB

If you wish you can download, extract and open the file to see how the project should look like by now. 

Section 7: Lesson 7: Creating the game "Pong"
07:48

In this lesson we take a look at the resources we are going to use in the game. We also prepare our code and load eveything.

3.41 MB

Download the zip and extract it. In it you will find the data folder with the files and the project.

07:46

In this video we get the images on the screen using shapes.

3.41 MB

If you wish you can download, extract and open the file to see how the project should look like by now. 

15:12

In this video we add movement to the pad and the ball.

3.41 MB

If you wish you can download, extract and open the file to see how the project should look like by now. 

10:24

In this video we create a very simple AI for the 2nd pad, and we add collision check for the ball.

3.41 MB

If you wish you can download, extract and open the file to see how the project should look like by now. 

12:34

In this video we finish up our game.

7.03 MB

If you wish you can download, extract and open the file to see how the project should look like by now. 

Instructor Biography

Luka Horvat , Independent Game programmer, designer

Luka is an independent game programmer and designer with much experience from different projects and many different programming languages. He has been interested in computer science and programming from his early years. That, and a passion for games lead him into the field of video game design and programming. In 2011 he started making tutorials on game development, and has now moved to Udemy to continue teaching others how to make games.

Join the biggest student community

5,900,000

Hours of video content

22,000,000

Course Enrollments

6,500,000

Students

Reviews

Average Rating
4.5
Details
  1. 5 Stars
    124
  2. 4 Stars
    44
  3. 3 Stars
    13
  4. 2 Stars
    5
  5. 1 Stars
    2
    • Austin Lee Covington

    Great for the beginner!

    This is a pretty damn good course for the beginners. I had very little programming experience before this course (3 years of high school experience in web design with the last year being Javascript and PHP learning through variables and if/else statements) so I didnt go into this course completely new, BUT on that same note Luka does an excellent job in explaining what he is doing and these topics and can really address to you the learner the elements your working on. The only gripe I have about this course is that the final project Pong has a bug where if the ball lands either on the top, top corner, bottom, or bottom corner it glitches back and forth between the shape of the paddle, which is annoying but hey you still made pong and learned a great deal of c++ in a short amount of time. One thing I highly advise students of this course to do is play around with the "settings" or attributes of the variables, i.e make shapes different sizes, make different speeds, change it up a bit. A fun thing to try to figure out is how to increase the ball's speed each round of pong, its a very VERY simple function and if your new to programming its a good exercise to test your knowledge on what you learned. Also try making the game 2 players. Again this is when you finish the course for the Pong examples but while going through the course play around with everything, it will help you a lot in the long run. Again this is a great course, just wish for the pong example it fixed the bug, but hey you learn very basic c++ and get the great reward of knowing you actually made something in a programming language which in itself pays for this course.

    • Aqdas Rauf

    Excellent course for beginners

    If you have any programming experience and looking at a starting point in video games, this is one of the better courses out there. Starts with basics and builds on it. My favorite part is the explanation behind almost every step unlike other tutorials and courses out there. However, I found the amount of content to be unsatisfactory. Perhaps a few more lessons to build on in continuation of the course? Suggest sprites, animation, alpha blending and few more basics, Hoping for more from this author.

    • Richard Patching

    Clear and Concise Introduction to SFML and C++ Games Development

    A very good introduction to SFML and C++ games development. Being C++ it would have been good if the author had shown how to architect the game into a more Object Oriented manner, hence the 4 stars instead of 5. Would recommend regardless!

    • Aaron Armstead

    Good course

    Well thought out and well made. Should be called Learn C++ Game Development with SFML as the material is specific to that engine. However, plenty of useful guidelines even if you won't be using SFML later on.

    • Bradley C Johnston

    Simple intro that helps with concepts

    This was a simple and easy to understand course with covers most of the basics (basic graphics, sounds and music, boundaries and collisions, and a bit of game play ). A good intro to games.

Show more reviews
Ready to start learning?
Preview this course

Beginner's Guide to C++

1Introduction

C++ is a general purpose programming language. Anyone already programming at the very least knows of the existence of this programming language. C++ is powerful and offers its developers a wide range of programming paradigms. The language is often favored by those who are building software that interacts with low level resources or the hardware of a computing device; even a large number of desktop applications prefer C++ due to its light weight runtime and flexibility. The language provides facilities that many other languages simply refuse to - possibly in order to keep things sane and simple. For example, with C++ it is possible to do low-level memory manipulation, which makes it an ideal choice for building hardware drivers, operating system kernels, software that runs on embedded systems, etc.

The wide array of features that C++ provides and the numerous ways of doing anything in C++ makes it a difficult task to put everything about this language in one post. In this article, we make an attempt to briefly touch on some aspects of the language that should let a programmer with some experience in other object oriented languages get started with C++.

2Getting Started

Getting started with C++ is quite easy on most platforms. All you need to do is install a compiler suite of choice, and you are good to go. Unless, of course, you prefer a particular integrated development environment (IDE). In which case, you can simply download one of the popular IDEs for C++ that is available for your platform, and use it.
On Linux, you may want to use the GNU Compiler Collection (GCC) for most of your C++ needs. On most Linux distributions, installing this compiler collection usually requires a single line of command, unless the compilers are already installed on your system. For example, in Arch Linux all you have to execute in your terminal is:

sudo    pacman    -S    gcc

On OS X, a C++ compiler (variation of LLVM) is already included, which should be sufficient for this beginner's tutorial.
On Windows, however, installing GCC might be a little more difficult. There are many IDEs available (such as CodeBlocks with MinGW) that you can possibly download as they come bundled with a set of compilers. Or, you can install MinGW separately. Otherwise, you can always use Microsoft's version of C++ by installing Visual Studio - which can often be a better choice given the ease of getting started.

3Hello World

What purpose does a programming language serve if it doesn't allow you to print the text "Hello, world!" to your terminal? The very first C++ program that we will look at is one that prints this simple text to the terminal. Create the following file and name it "hello.cpp":

~~~    cpp
#include < iostream >
using namespace std;

int main()    {
      cout << "Hello, world!" << endl;
      return 0;
}

To run this program, you must first compile it using a C++ compiler of your choice. We will be using the C++ compiler in the GNU Compiler Collection from the terminal throughout the article. If you are also using that, this is what you should be executing in your terminal to compile the program:

g++ hello.cpp

If all goes well, you should notice an executable file named "a.out" next to "hello.cpp" (on Windows, the file will be named "a.exe"). You may run the compiled program now from your terminal on *nix systems by issuing the following command:

./a.out

On Windows:

a.exe

This should print the following line of text on your terminal:

Dissecting "Hello World"

Directives

The way C or C++ compilers work is it turns your source code into executable programs in three high-level phases (preprocess, compile, and link). The first phase involves a preprocessor that handles all the directives - every line of your code beginning with a hash symbol. In this case, "#include" instructs the preprocessor to include the header file associated to the standard library "iostream". This, in essence, enables you to import functionalities into your code from external implementations; just like the "import" statements in Python, Go, etc., or the "require" function in Node.js. The underlying behavior of the "#include" directive is different, a bit more simple: it merely copies the contents of the named files in the spots where these directives appear.

Namespaces

C++ provides a mechanism - namespaces - that allows a bunch of functions and classes to be grouped under a named scope. This helps avoid name conflicts in large projects. Everything inside the standard library of C++ is declared within the "std" namespace. Without declaring "using namespace std;" in our program, we would have to prepend references to every element of the standard library with "std::". For example, instead of writing "cout << ...", we would have to write "std::cout << ...".

Entry

In C++, the entry point of any program is the "main" function. The signature of the main function is "int main()". However, "int main(int, char*[])" is also acceptable - which we will eventually take a look at later in this tutorial. The small bootstrap code that invokes your main function expects it to return the exit status of the program as an integer. Ideally, a program that runs and exits successfully yields an exit status of zero. Non-zero exit statuses are used to indicate different types of failure. In this program, we always return a zero.

Streams

As you might have guessed, the line of code that actually prints "Hello, world!" to your terminal is "cout << "Hello, world!" << endl;". The line itself may look self explanatory - you are _pushing_ (<<) a piece of text into "cout", that somehow prints it to the terminal. In this case, "cout" is an object that represents the standard output. In C world, it corresponds to the stream stdout. Finally, "endl" is what puts a new-line character at the end of the stream and forces the content of the stream to be flushed to the destination, which, in the case of stdout, is the terminal.

4The Language

C++, in terms of syntax, has some similarities to C. In many ways, C++ is a superset of what C offers. The following are some brief outlines about a few aspects of C++, which is hardly comprehensive, but should help us cover some general concepts and get used terminologies essential for the rest of the article. Unlike most other languages, C++ doesn't limit you to a single paradigm of programming. Other aspects, such as templating and exception handling, are being completely left out for some more advanced tutorials of C++.

Variables

C++, being a strongly-typed language, requires you to explicitly declare variables. A declaration typically involves indicating the name and type of a variable. An integer variable named "num" can be declared as follows:

~~~ cpp
int num;

To declare and initialize a variable at the same time, you can do this:

~~~ cpp
int num = 5;

C++ also allows you to declare arrays by simply appending a pair of square brackets after the variable name and putting the size of the array in between them:

~~~ cpp
int arr[10];

This declares an array by the name "arr" that can hold 10 integers. However, declaring arrays like this require you to know the size while you are writing the code. This is often not desirable, and that is where you need dynamic allocation of arrays. In C++, it is possible to dynamically allocate an array using the keyword "new[]":

int size = 10;
int arr[] = new int[size];

You may be wondering, how is this any different from the previous method of declaring arrays? After all both, are declaring an array of size 10. The difference is that in this case, "size" is a variable. And "size" doesn't always need to have the value 10. In fact, it can be any number, as long as your system memory is large enough to contain that array.

Speaking of memory, it is important to understand that in C++ not all memory allocations are treated equal. When you are declaring an array, the C++ runtime is allocating some memory for it. However, depending on how you allocated that array (or object), the memory may not be deallocated automatically. This is where C++ is significantly different from other programming languages that are garbage collected. In languages such as Python or Go, memory is deallocated by the garbage collector when it is no longer in use. In C++ not all allocated memory is deallocated automatically.

Whenever you use the "new" or "new[]" keyword, the memory allocated for that has a dynamic lifespan. And hence, it is only deallocated through an explicit use of the "delete" or "delete[]" keyword. From the example above, the array created through invocation of the "new[]" keyword will only be deallocated if the following code is executed:

delete[] arr;

Types

Like most typed languages, C++ comes with a handful of primitive types: bool, char, int, long, float, double, etc. Most of these types differ from one another based on the size data type that it can hold on to.
Most of these were already available in C, but C++ takes it a step further with things like the standard string library. By including the "string" library, you get better ways of managing strings of characters, compared to handling arrays of characters:

#include < string >
using namespace std;
int main() {
     string s = "an important string";
     return 0;
}

Operators

Variables are just part of a programming language, and incomplete without operators. For all primitive types in C++ there is a large number of operators available. Ranging from simple assignment operators to a plethora of arithmetic, logical, and bitwise operators. C++ even lets you define custom operator behaviors by letting you overload them. A standard library and its custom types make really good use of this feature.
- Arithmetic operators: +, -, *, /
- Comparison operators: ==, !=, >, <, >=, <=
- Logical operators: !, &&, ||
- Bitwise operators: &, |, ^, ~, <<, >>
- Pointer operators: *, &, ->
- And more
Some of these operators can be combined with the assignment operator to form much more concise expressions in some cases. For example:

a += b // equivalent to a = a + b

Flow Control

C++, just like C, comes with a bunch of conditional and loop constructs. It includes, but are not limited to, if-else statements, for and while loops, and more. Most of these behave almost exactly as you would expect them to, except in some cases.

~~~ cpp
if(month == 0) {
    cout << "January";
} else if(month == 1) {
    cout << "February";
// ...
} else if(month == 11) {
    cout << "December";
} else {
    cout << "not a month";
}

The construct above can be replaced with a switch statement.

~~~ cpp
switch(month) {
     case 0:
         cout << "January";
         break;
     case 1:
         cout << "February";
         break;
     // ...
     default:
         cout << "not a month";
}

However, switch statements are only limited to integer (int, long long int, etc.) and character (char) values and variables, and will not quite work with strings, which you may have seen being possible in languages like Go and JavaScript.
In C++ you have multiple ways of writing a loop statement. There is while, do-while, and for.

~~~ cpp
while(n > 0) {
     // ...
}

The code inside these curly braces will be executed repeatedly, as long as the condition (in this case 'n > 0') evaluates to true.

Functions

Functions in C++ have two parts: the signature and the body. As you would expect in any strongly-typed language, the arguments and the return type of the function must be explicitly mentioned. The following is the signature of a function that takes two int arguments and returns an int:

~~~
int add(int a, int b);

The implementation of this function can look something like this:

~~~
int add(int a, int b) {
     return a+b;
}

It is important to remember that the order in which these functions appear in a source code file is very important. If you want to use a function, it must be declared before it is called. For example, the following program will simply refuse to be compiled:

~~~
int sub(int a, int b) {
     return add(a, -b);
}
int add(int a, int b) {
     return a+b;
}

One thing that we can do to fix this is to move the function "add" above the function "sub". However, that may not work in situations where there is a circular dependency. What if "add" depended on "sub", and somehow "sub" depended on "add"? In most cases, the way we fix this is through declaring the functions first and then implementing them later on. In C++ you can declare a function just by stating its signature, and later on complete the implementation by defining its body:

~~~
int add(int a, int b); // Prototype of function add
int sub(int a, int b) {
     return add(a, -b);
}
int add(int a, int b) {
     return a+b;
}

Classes

Classes in C++, are meant to give data structure within your application. It is similar to struct used in C, with the added benefit of being able to define methods on them, as well as polymorphism. In fact, a minimal class looks very much like a struct in C:

~~~ cpp
class Fruit {
public:
     bool isCitric;
     double weight;
private:
     bool isEaten;
};

Here, the name of the class is "Fruit", and it has two public attributes ("isCitric" and "weight") and one private attribute ("isEaten"). Adding methods to the class is a two step process. The method signature is declared inside the class definition, and their implementation is added afterwards.

~~~ cpp
class Fruit {
public:
     // ...
     void eat();
     // ...
};
void Fruit::eat() {
     this->isEaten = true; }

Notice how this is similar to declaring function signatures and implementing their behavior later on. We can instantiate an object of this class by simply declaring a variable of this type:

~~~
Fruit f;

Here "f" is a variable of type Fruit. To access an attribute or a method of this object, we can use the structure reference operator:

~~~
f.isCitric;
f.eat();

When it comes to C++, these are separated into two files, usually for every class. A ".h" file which contains the class definition and method signatures and a ".cpp" file which contains the implementation of the methods. For example, for our Fruit class we could create two files named "fruit.h" and "fruit.cpp". The first file "fruit.h" would contain the definition of the Fruit class. The second file "fruit.cpp" would contain the implementation of the "Fruit::eat" method.
Classes in C++, as you would expect from any polymorphic programming language, can extend other classes through a simple syntax:

~~~ cpp
class Orange : public Fruit {};

Classes can also have one or more constructors and a destructor. These elements of a class are defined and declared in ways similar to that of methods, with some minor differences:

~~~ cpp
class Orange : public Fruit {
     Orange(); // Constructor
     ~Orange(); // Destructor
};
Orange::Orange() {
     this->isCitric = true;
     // ...
}
Orange::~Orange() {
     // No-op
}

In this snippet of code above, what we are doing is declaring a class that extends the class "Fruit" with a constructor and a destructor. Constructors are declared in a way that is similar to declaring methods, except that they do not have any return type and have the same name as the class itself. Destructors are also declared similarly, with the additional tilde symbol appearing before the name.

If you are already familiar with some other object oriented programming language, picking up on classes and inheritance in C++ should be simple. But that should not be a reason to underestimate the power of polymorphism in C++. There are a number of relevant features that are not often seen in other languages (such as friend classes, operator overloading etc.), which when used properly, can result in very elegantly coded programs. However, what is essential for us to realize is that these flexibilities, when used irresponsibly result in mistakes that are both hard to find and understand.

The purpose of this section was to show a simple example of classes and inheritance, and not an absolute guide to polymorphism in C++, as that itself must be built on solid understanding of what exactly polymorphism is, which is too large to currently explain.

Pointers

Pointers are a whole new world. They are special kind of values that let you access and manipulate memory in a completely different way. Typically, a variable is a way for us to address a certain portion of the computer's memory. However, you do not have much control over what portion of the computer's memory you are referring to.

There are two pointer related operators that we must know about at the very least if we want to use pointers in C++: "&" and "*".
The ampersand is an "address of" operator. Let's say you have an integer variable named "x". Any time you write "&x", it evaluates a pointer to variable "x" - what it means is that it evaluates to the address of the memory location where the variable x stores its value.
The asterisk, on the other hand, has two uses (apart from its role as an arithmetic operator - multiplication). When you declare a variable, putting an asterisk in front of the name makes it a pointer variable.

~~~
int *ptrToX;

If you were to initialize this pointer variable with an address, for example:

~~~
int x = 5;
int *ptrToX = &x;

...and if you tried to inspect the value of p, what you would see is a number that represents the address of the memory location where "x" stored the value 5. This, would be of much use if you could not retrieve the actual value via a pointer. This is where the second use of the asterisk operator comes in: indirection. If you were to inspect the result of the expression "*ptrToX", instead of just "ptrToX" you would actually get the value 5. When it comes to pointers to objects, especially accessing attributes and methods of objects, using pointers can lead to messy code. We may have a pointer to an instance of our Fruit class, and we want to access the method "eat" of that instance. To do that, we can use the indirection operator to first obtain the value, and then use the structure reference operator to access a member or method of the object:

~~~
Fruit f;
Fruit *ptrToF = &f;
(*ptrToF).isCitric;
(*ptrToF).eat();

Or, we can use a special operator known as the structure dereference operator to do the same:

~~~
ptrToF->isCitric;
ptrToF->eat();

5An Application

To provide a more hands on learning experience, we will implement a small todo application in C++. The objective is to walk through the code of this application, and understanding how the language and the standard library play their parts in the implementation. A number of robust user interface toolkits are available that work really well with C++. Qt is such a toolkit that is cross-platform, and in fact one of the most well built. However, to keep things simple we will build our todo application to only work through a command line interface.
We will begin with an empty directory for our project. Next we create our first ".cpp" file - "ytodo.cpp". Let us create the file and populate it with an noop, but valid, C++ program:

~~~
int main() {
     return 0;
}

Let us build the application by executing the following command in the terminal:

~~~
g++ *.cpp

...and run the compiled program:

~~~
./a.out

Remember, on Windows it will be "a.exe" instead of "./a.out". You will notice the program has been compiled and that running it produced no output in the terminal - which is expected, given the program is "empty".
Since we are building a todo application, we should at least define a simple class that would represent each individual task, including the task's title and done state. Let us create another file, name it "task.h" and populate it with:

~~~
#include < string >
using namespace std;
class Task {
public:
    string title;
    bool done;
};

As you already know, ".h" files are where declarations reside. Since our Task class does not have any method yet, we can skip creating a ".cpp" file for it now.

Next, we need to be able to handle command line arguments. If you can recall, the entry function main has variant where its signature accepts an integer and an array of character arrays. These parameters of the main function will allow us to determine what command line flags or arguments were included when the command was run. This means our main function should now have the following signature:

~~~
int main(int argc, char* argv[])

Here, argc is an integer indicating the number of arguments (elements) to expect in the array argv. Each element in argv is an individual argument from the command line. For example, running the built program as:

~~~
./a.out add "Learn C++"

Will set argc to 3, and argv to an array of 3 elements: "./a.out", "add" and "Learn C++".
Initially we want to implement three subcommands for our ytodo application.
- ls/list: list all tasks
- add: add a new task
- mark: mark a task as done
But before we can do that, we must add a few lines of code to help us parse these command
line arguments easily:

~~~ #include < iostream >
#include < map >
#include < string >

using namespace std;

int main(int argc, char *argv[]) {
     map < string, int > scmds;
     scmds[""] = 1;
     scmds["ls"] = 1;
     scmds["list"] = 1;
     scmds["add"] = 2;
     scmds["mark"] = 3;
     string arg1 = "";
     if(argc > 1) {
         arg1 = string(argv[1]);
     }
     if(scmds.find(arg1) == scmds.end()) {
         cout << "Invalid: " << arg1 << endl;
         return 0;
     }
     switch(scmds[arg1]) {
         case 1:
             cout << "Unimplemented: ls" << endl;
             break;
         case 2:
             cout << "Unimplemented: add" << endl;
             break;
         case 3:
             cout << "Unimplemented: mark" << endl;
             break;
     }
     return 0;
}

There are a few things worth mentioning regarding this code. First of all, the standard library headers included. The first one, "iostream", is something we are already familiar with from our Hello World example. The second and third headers are what provides us with a map data structure (similar to a dictionary or hash in other languages) and string implementation.

Inside the main function, the very first thing we are doing is creating a map named "scmds". The map has string keys and int values. The purpose of this is to create a mapping of subcommand names (strings) to unique integers representing the action to perform. Notice how we assign the same number for "ls" and "list", making them aliases to each other. Then, we determine if we have at least two arguments. If yes, we take the second element from the argv array and store it as a string in arg1. Otherwise, we set it to "ls", making it the default action when a subcommand is not included. Next we determine if a valid subcommand was issued by checking our map for the key's existence. When you make an attempt to find a key that doesn't exist in the map, as per specifications, the map returns an iterator value equivalent to the one returned by the end method of the map.

Finally, we switch based on the numeric value obtained from the map for the specific subcommand name and perform a task - for now we just indicate that the actions are not yet implemented.

You can compile and run the application by executing:

~~~
g++ *.cpp
./a.out

Adding Tasks: Files and Vectors

Let us now implement the "add" action. To do this, we need to accomplish three things:
- when the user tries to add something to the todo list, store it in a in-memory data structure
- when the application exits, store the contents of that data structure in a file
- when the application starts, read the contents of the file to restore the state of the data
structure
here is how we can do it:

~~~ #include < fstream >
#include < iostream >
#include < map >
#include < string >
#include < vector >
#include "task.h"

using namespace std;

vector < Task > tasks;
void load() {
     ifstream ifs("tasks.ytd");
     string l;
     while(getline(ifs, l)) {
         Task t;
         t.done = l[0] == '1';
         t.title = l.substr(2);
         tasks.push_back(t);
     }
     ifs.close();
}

void save() {
     ofstream ofs("tasks.ytd");
     for(vector < Task >::iterator it = tasks.begin(); it != tasks.end(); ++it) {
         ofs << (it->done ? 1 : 0) << " " << it->title << endl;
     }
     ofs.close();
}

string clean(string s) {
     string r = "";
     for(int i = 0, l = s.length(); i < l; ++i) {
         if(s[i] == '\r' || s[i] == '\n') {
             r += ' ';
         } else {
             r += s[i];
         }
     }
     return r;
}

int main(int argc, char *argv[]) {
     load();

     map < string, int > scmds;
     scmds[""] = 1;
     scmds["ls"] = 1;
     scmds["list"] = 1;
     scmds["add"] = 2;
     scmds["mark"] = 3;

     string arg1 = "";
     if(argc >= 2) {
         arg1 = string(argv[1]);
     }

     if(scmds.find(arg1) == scmds.end()) {
         cout << "Invalid: " << arg1 << endl;
         return 0;
     }

     switch(scmds[arg1]) {
        case 1:
             cout << "Unimplemented: ls" << endl;
             break;
         case 2:
             if(argc != 3) {
                   cout << "Missing task title" << endl;
                   return 0;
             } else {
                   string arg2 = string(argv[2]);
                   Task t;
                   t.title = clean(arg2);
                   tasks.push_back(t);
             }
             break;
         case 3:
             cout << "Unimplemented: mark" << endl;
             break;
     }

     save();
     return 0;
}

From a quick look, we can tell that three new functions have been added and some changes have been made to the second case of the switch statement in the main function. But at the same time, a couple of new headers have been included as well. Let us walk through the changes. First of all, the new standard library headers, namely "fstream" and "vector" provide the application with file reading/writing capabilities and a dynamic array-like data structure.

The "fstream" standard library header is similar to iostream, but instead of providing convenient stream access to the standard input/output, fstream provides similar ways of handling files. This time, we have included another header that belongs to our own project "./task.h". This is how we include the declaration of Task class in our application.

Just below the "using namespace" declaration, you can see a new variable declaration. Here, we have declared a vector named tasks. The vector will only store task objects, indicated by the mention of the class name within the angle brackets. So, a "vector < int >" type would actually be a vector of integers, just like "vector < Task >" is a vector of our class "Task". Next, out of the three new functions, the third one is the simplest: it takes a string, replaces all the newline and carriage return characters with ordinary space, and returns the new string. This is something we will use to clean up the task title that we get as an argument.

In our load function, we instantiate an ifstream (input file stream) and point it to the file named "tasks.ytd". We then use the standard getline function to fetch one line at a time from the file. We assume that each line is an individual task where the first character is either a 0 or a 1 (indicating not done and done), and the rest of the line after a space is the task's title. If the file doesn't exist, getline will immediately return a value that will cause the while-loop to not run at all. For every line that we process, we create a task object, set the title and done state, and push it to the tasks vector.

The save function, as you would expect, does the reverse of the load function. It loops over every task stored in the tasks vector, and puts them in the "tasks.ytd" file. By default, ofstream (output file stream) opens the file and replaces its contents with what you write to it. The for-loop is a bit of a handful. First of all, the type of the value we iterate on looks a little alien. This is because, when looping over a vector, it is actually convenient to use an iterator object provided by the vector. The way it works is you call the vector's begin method to get an iterator pointed at the very beginning of the vector. At every step, you "increment" the iterator to move it to the next element. The iterator itself behaves like a pointer, so you need to dereference it to access the actual value. You continue the loop until the iterator reaches the end. You treat "ofs" as you would treat cout, by streaming data into it. Once all the data has been passed to "ofs", you close the file.

Finally, in the second case that handles the "add" subcommand, we check if we have sufficient number of arguments. If yes, we create a task object and push the tasks vector. The load and save function invocation at the beginning and end of the main function handles the synchronization of the in-memory and file-based data storage for this application. You can now compile the application:

~~~
g++ *.cpp

...and try adding a task by executing:

~~~
./bin/ytodo add "Learn C++"

You will notice that a file named "tasks.ytd" has been created. Opening it with your favorite text editor should show the task you have just added:

~~~
0 Learn C++

Listing Tasks

At this point, implementing the "ls" subcommand should be a simple feat:

~~~
int main(int argc, char *argv[]) {
     // ...
     switch() {
         case 1:
             for(int i = 0, l = tasks.size(); i < l; ++i) {
                 Task t = tasks[i];
                 cout << (i+1) << ". " << t.title << " [" <<
                 (t.done ? "X" : " ") << "]" << endl;
             }
             break;
         // ...
     }
     // ...
}

Here, we loop from 0 to l, where l is the size of the vector tasks, and we print one line for every task. First we print a serial number, then the task's title, and finally a pair of square brackets that would have an X in-between them for tasks that have been marked as done. You can now compile and run the program to print all the tasks that you have added to the list:

~~~
g++ *.cpp
./a.out ls

The idea behind printing these serial number is to provide the user with an easy way to reference the tasks. For example, next we would like to implement the "mark" subcommand which will mark tasks as done. With these serial numbers, the user should be able to mark the tasks as done by referring to these numbers. To mark the second task from the list, the user can execute:

~~~
./a.out mark 2

Marking Tasks as Done

Implementing this "mark" subcommand may be easier than you think:

~~~
int main(int argc, char *argv[]) {
     // ...
     switch() {
         // ...
         case 3:
             if(argc < 3) {
                 cout << "Missing task number" << endl;
                 return 0;

             } else {
                 string arg2 = string(argv[2]);
                 int no = stoi(arg2);
                 if(no < 1 || no > tasks.size()) {
                     cout << "Invalid task number" << endl;
                     return 0;
                 }
                 Task &t = tasks[no-1];
                 t.done = true;
             }
             break;
     }
     // ...
}

Just like "add", for this subcommand we determine if the third argument is present or not. We extract the third argument as a string, convert it using the standard stoi function, and check if the number is within a valid range. We then find the appropriate task object in the vector and set its done attribute to true.

There is one small detail worth pointing out here. Notice the "&" symbol before the variable name "t"? That makes this variable a reference to the element of the vector, instead of making the program copy the element of the vector into a new memory location. References work in a way similar to that of pointers, except that they have a little more restrictions imposed on what you can do with them. Without this symbol, any changes made to "t" wouldn't have any effect on the actual task element inside the vector. If "t" wasn't a reference to the element, it would have been a copy, and changes made to the copy of an object wouldn't have any effect on the original object.

Sorting Tasks: Overridden Operators and STL Algorithms

As you can see, we can now add small nifty features to this tool with small, incremental updates. Let us add another feature that would sort each task based on its status. This will let us move all the completed task to the bottom of the list. For this, we will use the "sort" algorithm that comes with the standard library.
Before we use the "sort" function, we need to modify our Task class a little for it to work with the function. There are many ways of using the function, one of which involves defining a custom less than operator for your custom data type or class in this case. Overriding an operator involves defining a method-like element for the class:

~~~
// task.h
// ...
class Task {
     // ...
     public operator<(const Task &b) const;
};

And we will provide the implementation of this overriden operator in our "task.cpp" file:

~~~
#include "task.h"

bool Task::operator<(const Task &b) const {
     return !this->done && b.done;
}

This allows you to compare two task objects with the less than operator. Given two tasks a and b, a is less than b only if a is not done, but b is done. The const keywords before the argument type and after the function's signature is there to assure the compiler that the object b passed as the argument will not be modified by the function and the function will also not modify the object at "this".
Finally, we need modify our "ytodo.cpp" file to use the sort algorithm:

~~~ #include < algorithm >
// ...
int main(int argc, char *argv[]) {
     // ...
     scmds["sort"] = 4;
     // ...
     switch(scmds[arg1]) {
         // ...
         case 4:
             sort(tasks.begin(), tasks.end());
             break;
     }
     // ...
}

And that is it. All you have to do to sort the vector of tasks is to:
1. Define a less than operator for the class.
2. Include the algorithm's standard library.
3. Invoke the sort function with the beginning and the ending iterators of the vector.
You can now compile and run the "sort" subcommand to organize the list by moving all the tasks that have been marked as done to the bottom.

~~~
g++ *.cpp
./a.out sort

6Conclusion

Learning C++ is usually quite a different experience from learning any other modern programming language. This is probably attributed to the age of the language, or may even be its less-than-high-level nature - even though C++ is in fact a high level language. C++ may not be the best choice for building your next web application server, but it is certainly a powerful language that can cover a lot of ground. With its performance characteristics and versatility, C++ is often a great language for building software that is closer to your bare machine (such as hardware drivers and operating systems), or software that would like to make the use of every bit of performance that the hardware can provide - such as games, real-time applications, embedded systems, missile thrust vector control systems, and more. Just like with any other language, mastering C++ is a matter of patience and practice. This article may have barely scratched the surface, but we hope it has given you an insight into what you can expect from C++ and a starting point from where you can continue to play with the language and continue to learn more about it.

This tutorial was made in collaboration with TopTal.