usaco-guide/additionalContent/Running_Cpp.mdx

# Using C++ Online

- [OnlineGDB](https://www.onlinegdb.com/)
  - online compiler with an embedded GDB debugger
  - can be buggy sometimes
  - supports files and file I/O
- [CSAcademy](https://csacademy.com/workspace/)
  - pretty nice (unless you get "Estimated Queue Time: ...")
  - "saved locally" will not save your code if you close the tab, press Command-S to save.
- [Ideone](http://ideone.com/)
  - okay ... has the bare minimum you need for running C++
  - make sure your code is not public (see below)
  - sometimes erases your code when you first create it (so get in the habit of copying your code first)

<warning-block>

If you use Ideone during an online contest (such as a Codeforces round), you **must** ensure that your code is set to be private. **You might be punished for cheating if another person finds and copies your code during the contest, even if you never intentionally provide the code to anyone.**

Even if you are not doing an online contest, you might want to set your code to be private for other reasons.

</warning-block>

You can also share code with [pastebin](https://pastebin.com/) or [hastebin](https://hastebin.com/).

# Using an IDE

These often have C++ support already built-in.

<resources>
  <resource
    title="Visual Studio Code"
    url="https://code.visualstudio.com/"
    starred
  >
    Lightweight, fast IDE, but requires some configuration. See{' '}
    <a href="http://www.csc.kth.se/~jsannemo/slask/main.pdf">PAPC 2.1</a> for
    setup instructions.
  </resource>
  <resource title="Geany" url="https://www.geany.org/" starred>
    Lightweight, frequently used at IOI.
  </resource>
  <resource title="Visual Studio" url="https://visualstudio.microsoft.com/vs/">
    Heavier cousin of VS Code. VS Code is better for competitive programming.
  </resource>
  <resource title="Codeblocks" url="http://www.codeblocks.org/">
    Bad on Mac.
  </resource>
  <resource title="XCode" url="https://developer.apple.com/xcode/">
    Mac only.
  </resource>
  <resource title="CLion" url="https://www.jetbrains.com/clion/">
    Requires a license, but{' '}
    <a href="https://www.jetbrains.com/community/education/#students">
      free for students
    </a>
    .
  </resource>
</resources>

# Using Command Line

Alternatively, run C++ from the command line and use a text editor of your choice.

## Text Editors

<resources>
  <resource title="Sublime Text 3" url="https://www.sublimetext.com/" starred>
    Fast, lightweight. Keeps asking you to purchase a license ...
  </resource>
  <resource title="Atom" url="https://atom.io/">
    From the makers of Github.
  </resource>
  <resource title="Vim" url="https://www.vim.org/">
    Classic text editor, usually preinstalled on Linux.
  </resource>
</resources>

Vim is probably the easiest way to print syntax-highlighted code on Mac, see the response to [this post](https://stackoverflow.com/questions/1656914/printing-code-with-syntax-highlighting).

### Sublime Text Notes (Ben)

- I prefer the **Mariana** color scheme in place of the default.
  - open command palette (Cmd-Shift-P) -> change color scheme
- [`subl` symlink](https://www.sublimetext.com/docs/3/osx_command_line.html)
  - Using `/usr/local/bin/subl` instead of `~/bin/subl` worked for me on OS X Mojave.
- [Snippets](https://www.granneman.com/webdev/editors/sublime-text/top-features-of-sublime-text/quickly-insert-text-and-code-with-sublime-text-snippets)
  - I use [this python script](https://github.com/bqi343/USACO/blob/master/Contests/Tools/Other/makeSnip.py) to update all of my templates. (details?)
- [Package - Sublime Linter (GCC)](https://packagecontrol.io/packages/SublimeLinter-gcc)
  - highlights compilation errors and warnings from `-Wall`

<!--   - [FastOlympicCoding Addon](https://github.com/Jatana/FastOlympicCoding)
    - not that useful
    - stress testing is covered in "Debugging"
    - linting is covered by the above
    - debugger only works with clang
   - [Editing Build Settings](https://stackoverflow.com/questions/23789410/how-to-edit-sublime-text-build-settings)
    - no need to do this if you just use command line to compile & run

 -->

## On Linux

GCC is usually preinstalled on most Linux distros. You can check if it is installed with

```
whereis g++
```

If it is not preinstalled, you can probably install it using your distro's package manager.

## On Windows

### MinGW

One option is [MinGW](http://mingw.org/).

First, download and run the [MinGW installer](https://osdn.net/projects/mingw/downloads/68260/mingw-get-setup.exe/). Once it's installed, open the MinGW Installation Manager, click on Basic Setup on the left, and select `mingw32-gcc-g++-bin` for installation.

[Adding MinGW to PATH](https://www.rose-hulman.edu/class/csse/resources/MinGW/installation.htm)

### WSL

Another good option is Windows Subsystem for Linux (WSL) which is what I (Anthony) personally use, although it may be more difficult to properly set up.

[VSCode Docs for WSL](https://code.visualstudio.com/docs/cpp/config-wsl) (difficult for beginners)

Nathan Wang: If you want to code in (neo)vim, you can install WSL and code through WSL bash.

- Note that WSL has a max stack size of 64MB; I am unsure if this limitation is resolved yet.
- Note that WSL/vim clipboard integration is imperfect.

## On Mac

[Clang](https://en.wikipedia.org/wiki/Clang) is the default compiler for Mac OS X, but you should use [GCC](https://en.wikipedia.org/wiki/GNU_Compiler_Collection)'s g++ since that's what [USACO](http://www.usaco.org/index.php?page=instructions) uses to compile your code.

### Installation

1.  Open the **Terminal** application and familiarize yourself with some basic commands.

    <resources>
      <resource
        source="Jim Hoskins"
        title="Intro to OS X Command Line"
        url="https://blog.teamtreehouse.com/introduction-to-the-mac-os-x-command-line"
        starred
      ></resource>
      <resource
        source="Rahul Saigal"
        title="Mac Terminal Cheat Sheet"
        url="https://www.makeuseof.com/tag/mac-terminal-commands-cheat-sheet/"
        starred
      ></resource>
    </resources>

2.  Install XCode command line tools.

    ```
    xcode-select --install
    ```

    If you previously installed these you may need to update them:

    ```
    softwareupdate --list # list updates
    softwareupdate -i -a # installs all updates
    ```

3.  Install [Homebrew](https://brew.sh/).

4.  Install gcc with Homebrew.

    ```
    brew install gcc
    ```

    According to [this](https://stackoverflow.com/questions/30998890/installing-opencv-with-brew-never-finishes) if `brew` doesn't seem to finish for a long time then

    ```
    brew install gcc --force-bottle
    ```

    probably suffices.

5.  You should be able to compile with `g++` or maybe `g++-#`, where # is the version number (ex. 9). Running the following command

    ```
    g++-9 --version
    ```

    should display something like this:

    ```
    g++-9 (Homebrew GCC 9.2.0_2) 9.2.0
    Copyright (C) 2019 Free Software Foundation, Inc.
    This is free software; see the source for copying conditions.  There is NO
    warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    ```

## Running With the Command Line

Consider a simple program such as the following, which we'll save in `name.cpp`.

```cpp
#include <bits/stdc++.h>
using namespace std;

int main() {
  int x; cin >> x;
  cout << "FOUND " << x << "\n";
}
```

It's not hard to [compile & run a C++ program](https://www.tutorialspoint.com/How-to-compile-and-run-the-Cplusplus-program). First, open up Powershell on Windows, Terminal on Mac, or your distro's terminal in Linux. We can compile `name.cpp` into an executable named `name` with the following command:

```
g++ name.cpp -o name
```

Then we can execute the program:

```
./name
```

If you type some integer and then press enter, then the program should produce output. We can write both of these commands in a single line:

```
g++ name.cpp -o name && ./name
```

### Redirecting Input & Output

If you want to read input from `inp.txt` and write to `out.txt`, then use the following:

```
./name < inp.txt > out.txt
```

See "Intro - Introductory Problems" for how to do file input and output within the program.

### Compiler Options (aka Flags)

Use [compiler flags](https://developers.redhat.com/blog/2018/03/21/compiler-and-linker-flags-gcc/) to change the way GCC compiles your code. Usually, we use the following in place of `g++ name.cpp -o name`:

`g++ -std=c++17 -O2 name.cpp -o name -Wall -Wextra -Wshadow`

Explanation:

- `-O2` tells `g++` to compile your code to run more quickly (see [here](https://www.rapidtables.com/code/linux/gcc/gcc-o.html))
- `-std=c++17` allows you to use features that were added to C++ in 2017. USACO currently uses `-std=c++11`.
- `-Wall -Wextra -Wshadow` checks your program for common errors. See "General - Debugging" for more information.
- [Summary of Options](https://gcc.gnu.org/onlinedocs/gcc/Option-Summary.html)

You should always compile with these flags.

### Adding Shortcuts (Mac and Linux only)

(alternatives for Windows?)

Of course, retyping the flags above can get tedious. You should define shortcuts so you don't need to type them every time!

[Aliases in Terminal](https://jonsuh.com/blog/bash-command-line-shortcuts/)

Open your `.zshenv` with TextEdit

```
open -a TextEdit ~/.zshenv
```

or some text editor (ex. sublime text with `subl`).

```
subl ~/.zshenv
```

You can add **aliases** and **functions** here, such as the following to compile and run C++.

```
co() { g++ -std=c++17 -O2 -o $1 $1.cpp -Wall -Wextra -Wshadow; }
run() { co $1 && ./$1 & fg; }
```

Now you can easily compile and run `name.cpp` from the command line with `co name && ./name` or `run name`. Note that all occurrences of `$1` in the function are replaced with `name`.