Getting Started

This page will document the basics of C++ along with how to setup C++ on your machine.

Installation

First, we must install an integrated development environment, commonly known as an IDE. An IDE allows us to edit and run code.

You can skip this step if you use online IDEs like ide.usaco.guide or Replit.

The most common IDE used is VSCode, but there are many options as well. For example, a great alternative is Dev C++.

This website will be using VSCode as the main IDE.

Next, we want to install a compiler. Different operating systems have different methods of installation, so just read the section detailing your OS.

Linux

Installation is simple, just run the following two commands:

sudo apt-get update
sudo apt-get install build-essential gdb

Then, to check your installation, run the following command:

gcc -v

This applies for WSL (Windows Subsystem for Linux) as well.

Windows

We will be using MSYS2 in this website.

First, download the installer found on the homepage. Follow the prompts that it asks you.

Once installed, open MSYS2 UCRT64 and use the following command to install gcc:

pacman -S mingw-w64-ucrt-x86_64-gcc

To check your installation, type one of the following in the command prompt or powershell:

gcc --version
gdb --version
g++ --version

MacOS

In the terminal, write:

xcode-select --install

Check your installation with:

clang --version

Creating a Project

Extensions

When using C++ in VSCode, make sure to install the C++ Extension. This is called C/C++ in the extension marketplace.

Optionally, you can install C/C++ Extension Pack as well as C/C++ Themes to enhance your experience.

Creating a Directory

TIP

If using VSCode, you can open a folder by moving (cd) to their directory and then typing code . This will open that directory, which will be called your "workspace"

Create a directory and open it with the following:

mkdir MyProject
cd MyProject
code .

Then, press the new file button in the explorer to make a new file. Name it test.cpp and past the following:

#include <iostream>
int main () {
    std::cout << "Hello, world!\n";
    return 0;
}

Don't worry if you don't understand any of the code written above. It will all be explained in the next section.

Running the Code

In VSCode, press the play button on the top right, below the minimize (-) button. On the first run, you will be prompted to choose a compiler.

Linux: choose the g++ build and debug active file configuration

Windows: choose the C/C++: g++.exe build and debug active file configuration.

MacOS: choose the C/C++: clang++ build and debug active file configuration.

During your first run, a .vscode folder will be created in your workspace. This will contain a .json file that called tasks.json.

The tasks.json file varies between operating systems. The variation is not too large though. On Windows, it should look similar to this.

{
    "tasks": [
        {
            "type": "cppbuild",
            "label": "C/C++: g++.exe build active file",
            "command": "C:\\msys64\\ucrt64\\bin\\g++.exe",
            "args": [
                "-fdiagnostics-color=always",
                "-g",
                "${file}",
                "-o",
                "${fileDirname}\\${fileBasenameNoExtension}.exe"
            ],
            "options": {
                "cwd": "${fileDirname}"
            },
            "problemMatcher": [
                "$gcc"
            ],
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "detail": "Task generated by Debugger."
        }
    ],
    "version": "2.0.0"
}

Debugging

Do you remember the play button you pressed to run it? There is a downward pointing arrow next to it, and when clicked, it shows the option to either run or debug.

Because we are concerning debugging in this section, choose the Debug C/C++ file. Similar to running a file, on the first debug you will get a prompt asking for your desired compiler. This changes between operating systems.

Linux: select C/C++: g++ build and debug active file

Windows: select C/C++: g++.exe build and debug active file

MacOS: select C/C++: clang++ build and debug active file

When debugging, there is something called a breakpoint. You can create a breakpoint by hovering over the line number of your code and clicking the red dot that appears to your left. Clicking on the dot again deactivates the breakpoint.

A breakpoint momentarily pauses your code and allows you to monitor your variables and their values at that timestamp.

You might have noticed that a little rectangle has appeared with a few arrows and a stop button.

The details container below explains the use of all six buttons as well as the gray rectangle of six dots.

Details

The leftmost object is a gray rectangle made out of six dots. You can hold it to drag the little rectangle with the buttons around.

The first button skips to your next breakpoint.

The second button skips to your next nonempty line.

The third and fourth button are not very useful for competitive programming.

The fifth button resets your debugging process, and makes you restart from the beginning.

The last button stops the debugging process.

The last important concept of debugging is a watch. In the watch window, you can add a new expression. The window displays the value of that expression at each breakpoint/line.

Importing/Including

In C++, there is a standard library of classes and functions that is written in and part of the C++ language.

In order to implement this library, simply import it directly into your code.

#include <bits/stdc++.h>

With this import statement, you are now able to any function part of the C++ library, including inputting and outputting, sorting, etc.

WARNING

VSCode sometimes says there is an error when you try including <bits/stdc++.h> This can be fixed easily, just follow this guide published on Codeforces.

This is okay though, as it usually compiles in USACO.

It is best practice to include libraries separately but <bits/stdc++.h> is good for competitive programming.

However, this standard library can also be split into several smaller libraries, which depending on their usage could decrease runtime. We will introduce how to import these smaller libraries later on in the course when we need to use those libraries.

Here are some commonly used and important libraries that could be used in place of the standard library.

Library	Usage
#include <iostream>	Allows for Input and Output statements
#include <algorithm>	Includes the sort and search functions
#include <climits>	Allows for access of largest and smallest integers in C++
#include <string>	Allows for manipulation of Strings
#include <math.h>	Provides the square root, logarithm, and power functions

They are imported at the top of your code like this:

#include <iostream>

int main () {
    //do stuff
    return 0;
}

TIP

Don't worry if you don't understand this code yet. It will be explained later.

Namespaces

Namespaces are provided by the standard libraries in C++, and to use these functions provided by the previous libraries, you need to identify the namespace before calling any of the functions. Almost always, you will be using the std namespace. For example, when printing Hello World!:

#include <iostream>
int main() {
    std::cout << "Hello World!" << std::endl;
}

Before each and every function to be used, you must write std:: preceding the function. However, usually coders use a way to bypass the necessity of writing these identifiers, and this can be easily solved by declaring the identifier at the beginning of the function. The previous code block can now be changed into:

#include <iostream>

using namespace std;

int main() {
    cout << "Hello World!" << endl;
}

Starting to Code

The next and final line in the header is the main function. The code will only be run if it is written inside of this main function. To initialize this main function, the following code will be sufficient.

int main() {
    //code goes here
}

Let's break apart the syntax of this function. The first word, int signifies that an integer is returned as part of the function. Quite often in competitive coding, there will be no need to return anything from the main function, and although there will be nothing wrong, it is best coding practice to return the value 0 at the end of the function.

int main() {
    // code goes here
    return 0;
}

Next, main signifies that the following code is part of the main function, and by defauly is the function that a C++ compiler will run. The empty parentheses signifies that no values are being put into the function, and the brackets represent the lines where the function is written in. For example, any lines written before the open bracket and after the closed bracket will not be run as part of the main function.

Macros

Macros are used to shorten code, and can be thought of as abbreviations in coding. Macros are initialized in the header, usually placed after imports, but before namespaces. The following is an example of a commonly used header setup.

#include <iostream>

#define PRINT(x) cout << x << endl;
using namespace std;

int main() {
    PRINT(123);
    return 0;
}

Expected Output:

123

In this code, the macro allows the coder to simply write PRINT(x) instead of the real printing line throughout the entire document. All macros are in the format of macro name followed by macro definition.

Additionally, macros can be used to set a constant value, such as pi.

#define PI 3.14159

Sometimes, datatypes have names that are a burden to type. An example of these data types is a long long, which has been increasingly popular in recent contests.

You can make a type alias for it with the following code:

typedef long long ll

Then, in later code segments, you can write

ll x = 1234567890;

One more way to do this is to type using.

using ll = long long;

Conclusion

With your IDE and compiler installed, you should be set for future C++ projects. This guide covered many aspects about VSCode, but did not go in depth.

It is up to you to discover more capabilities of your IDE.

Your basic knowledge of include files, namespaces, and macros will be useful tools in your competitive programming journey.