01 C++ Notes

Getting Started with C++

C++ Notes

Compiler and Debugger Tools

Three tools sit behind every C++ program you run. Two of them turn your source code into something the machine can execute, the third helps you when execution goes wrong.

• The compiler checks the legality of code, not its logic or bugs. It cares whether the code is valid C++, not whether it does what you meant.
• The compiler converts your code into machine code, and while doing that it also produces a map back to the original source lines.
• The debugger keeps track of machine code during execution, at runtime, which the compiler never does.
• When a bug occurs, the debugger uses that map from the compiler to point straight back to the corresponding line in your original source.

Your First Program: Hello World

• #include <iostream> loads the library for input and output, and it's also what makes things available under the std namespace.
• int main() is the entry point of a C++ program. It exists outside any class, unlike Java where everything has to live inside one.
• A method is a function that exists inside a class. A plain function outside a class is just called a function, not a method.
• return 0 reports success to the OS. Any non-zero value means failure. If you leave it out entirely, success is assumed.

cout and cin Internals

• std::cout is an object of type std::ostream. It doesn't print directly, it sends data to its internal buffer, which is a std::streambuf object.
• The stream insertion operator << inserts data into cout, and cout then returns itself, which is exactly why you can chain multiple insertions in one line.
• The buffer flushes, meaning it empties and actually displays its contents, in three situations: when it becomes full, when std::endl is inserted, or right before input is about to be taken through std::cin.
• std::cin is tied to a separate buffer that receives input, following the path keyboard, then OS, then the cin buffer, then finally your variable.
• cin and cout do not share a buffer, so they never interfere with each other even when used back to back.

Errors and Warnings

Functions, the Basics

• A statement is a meaningful piece of code that ends with a semicolon ;.
• A function is a collection of statements grouped together to perform a task.
• Every function must be declared before the main function, so the compiler already knows it exists by the time it's called.

Real Compilation Flags (VS Code Setup)

Add these flags to your VS Code tasks.json under args to enable the C++20 standard and turn on strict warnings.

Input and Output

The Streams

Data Flow

• std::cout << name; → variable → cout object → buffer → display
• std::cin >> first; → data → OS → buffer → cin object → variable
• std::getline(std::cin, name); → reads the full line, including spaces, straight from the buffer into the variable

The Leftover Newline Problem

When you read an integer with cin >> x, the newline character you pressed to submit it stays behind in the buffer. If getline runs right after, it immediately reads that leftover newline instead of waiting for real input, and hands you back an empty string.

• Discards exactly one character from the buffer, which covers the leftover newline in the simple case.
• Will fail if more than one unwanted character is sitting in the buffer.

• std::ws is a stream manipulator that extracts and discards all leading whitespace from the buffer before getline reads anything.
• It handles multiple leftover whitespace characters, which makes it more reliable than ignore() in practice.

How a Program Actually Runs: The Execution Memory Model

When a program runs, the OS loads it into memory. The program area holds the instructions. Variables live in a separate data area in RAM. The CPU fetches instructions from the program area, executes them, and returns to the next instruction using a return address stored in its own register.

  a = 10       (int)
  b = 5        (int)
  c = f_add(a,b)
  ...

Step by step, this is what actually happens from launch to exit:

1. Your source code sits on the hard drive. It's just a text file with instructions, nothing is running yet.
2. When you run the program, the OS loads it from the hard drive into RAM. The instructions go into the program area and get assigned memory addresses, like 0001, 0002, and so on.
3. The CPU starts at address 0001 and fetches the first instruction. It reads it, executes it, then moves on to the next address.
4. When a variable is declared, like a = 10, the value gets stored in a separate section of RAM called variable storage. The CPU reads from and writes to this area as needed.
5. When a function is called, like f_add(a, b), the arguments are pushed onto the stack in RAM. The CPU stores a return address in its register so it knows exactly where to come back to once the function finishes.
6. When a print statement runs, the data goes into the cout buffer first. The buffer flushes to the console when it's full, on endl, or right before input is taken.
7. When the program ends with return 0, the OS clears the RAM it had allocated and the process terminates.

Code Example: main.cpp

#include <iostream>

// function declaration must appear before main
int sum(int a, int b);

int main() {
    std::cout << "Enter first num: ";  // prints: Enter first num:
    int first;
    std::cin >> first;               // reads integer from keyboard

    std::cout << "Enter second num: "; // prints: Enter second num:
    int second;
    std::cin >> second;              // reads integer from keyboard

    // std::cin.ignore() discards only ONE leftover newline, may fail if more whitespace
    // better approach below using std::ws

    int result = sum(first, second);  // calls sum(), stores return value

    std::string name;
    std::cout << "What is your name: "; // prints: What is your name:
    std::getline(std::cin >> std::ws, name); // std::ws discards leftover whitespace first

    std::cout << "Hello : " << name << '\n'; // prints: Hello : Hassan
    std::cout << "Result: " << result << '\n'; // prints: Result: 15

    return 0; // reports success to OS
}

// function definition can appear after main since we declared it above
int sum(int x, int y) {
    int z = x + y;
    return z; // returns result back to caller
}

C++ Features

C++ is built in three layers, and each one depends on the one before it.

Core Language

The basic building blocks of C++ itself. It defines the rules, syntax, and behavior of the language, and it's the foundation everything else is written on. Nothing else in C++ can exist without this layer.

• Variables, data types
• Functions, classes, objects
• Control flow: if, loops
• Pointers, references
• Templates, inheritance
• Memory management

Standard Library

A collection of ready-to-use components built using C++'s own core features. It handles common tasks so you don't have to deal with low-level details manually every time, which is what makes real-world programming practical and efficient.

STL, the Standard Template Library

A specialized subset of the Standard Library that gives you practical, optimized implementations of common data structures and algorithms, so you don't have to build them from scratch. It's built using templates, which is exactly why every STL component works with any data type without needing to be rewritten per type.

Closing

That covers the ground floor: tools, hello world, how input and output actually move through the program, and where C++ as a language ends and its libraries begin. Next up, the data types themselves.