Getting Started

1. Choose a compiler

Use one of these toolchains:

• GCC
• Clang
• MSVC

2. Create a first file

#include <iostream>

int main() {
    std::cout << "Hello, C++!\n";
}

Save it as main.cpp.

3. Compile it

GCC / Clang

g++ -std=c++23 -Wall -Wextra -pedantic main.cpp -o app

MSVC Developer Command Prompt

cl /std:c++23 /W4 main.cpp

4. Run it

./app

5. Mental model

A C++ source file is compiled into machine code. The compiler checks syntax and types before you run the program.

For now, the important habit is simple: edit, compile, read warnings, run, then repeat in very small steps.

6. Next steps

• Learn variables and types
• Practice console input and output
• Turn warnings on from day one

7. A better first compile command

As soon as you move past "hello world", prefer separate debug and release builds.

g++ -std=c++23 -Wall -Wextra -Wpedantic -g -O0 main.cpp -o app-debug
g++ -std=c++23 -Wall -Wextra -Wpedantic -O2 main.cpp -o app-release

The debug build helps investigation. The release build shows the performance and code generation you will eventually ship.

8. A slightly more realistic first program

#include <iostream>
#include <string>

int main() {
    std::string name;
    std::cout << "Enter your name: ";
    std::getline(std::cin, name);
    std::cout << "Hello, " << name << "!\n";
}

This introduces input, output, variables, and string handling without adding too much complexity at once.

9. First project structure

project/
    src/
        main.cpp
    include/
    build/

Start small, but keep generated files out of your source directories.

10. Separate compilation in one glance

Real programs are usually split across more than one file.

// math.h
int add(int a, int b);

// math.cpp
int add(int a, int b) {
    return a + b;
}

// main.cpp
#include <iostream>
#include "math.h"

int main() {
    std::cout << add(2, 3) << '\n';
}

That split leads naturally to the compile-and-link mental model.

11. Habits worth adopting immediately

• Read warnings before running the program.
• Prefer standard library facilities over handwritten utilities.
• Compile often and keep the code building after every small change.

12. What the compiler is actually doing

At a high level, a normal C or C++ build goes through these stages:

1. preprocessing: handles #include, macros, and conditional compilation
2. compilation: parses the source and produces object code
3. linking: combines object files and libraries into the final executable

That mental model helps explain common errors such as missing headers, undefined references, and duplicate symbols.

13. Common beginner errors

• forgetting a semicolon
• using a variable before declaring it
• missing an #include for a standard library type
• compiling one file but forgetting to link another implementation file

When a build fails, read the first error carefully before chasing later cascading messages.

14. Your first useful standard-library tools

Even tiny programs benefit from learning a few standard components early:

• std::string for text
• std::vector for dynamic collections
• std::optional for maybe-a-value results
• std::span for non-owning views into contiguous data

Those types let you avoid many raw arrays, manual memory tricks, and ad hoc error codes.

15. Where to look things up

Use this site in three layers:

• tutorials for the learning path
• cheat sheets for quick reminders
• the reference section for keywords, types, headers, and library families

16. Set up your editor or IDE next

Once the compiler is working, your next step should be a usable editing and debugging environment.

• If you want a lightweight setup, use Visual Studio Code with the C/C++ and CMake extensions.
• If you want the most integrated Windows experience, use full Visual Studio with the Desktop development with C++ workload.
• If you want a cross-platform CMake-focused IDE, CLion is a strong option.

Continue with IDE Setup for C++ before you start building larger examples.