Introduction #

When you are writing C++ files, you’ll often see lines at the very top that start with #, like this:

#include <iostream>

If you are new, this might look like some magic syntax that you have to memorize. Let me explain it the way someone who has written real projects would think about it.

What “Preprocessor” Really Means #

Before your C++ code goes to the compiler, there’s a small program that runs first — this is called the preprocessor.
Its job is simple: prepare the code for the compiler.

It doesn’t understand C++ logic like functions or loops — it only handles a few directives. Think of it as a text processor that changes your source file before compilation.

The lines that the preprocessor understands all start with #. These are called preprocessor directives.

Bringing Code From Elsewhere ( #include ) #

The most common directive you’ll use is #include.

When you write:

#include <iostream>

you are basically telling the preprocessor:

“Before you compile this file, go and paste everything from the iostream header here.”

Why do we do that?
Because std::cout and other input/output utilities are defined in that header.
If you don’t include it, the compiler won’t know what std::cout is, and you’ll get errors.

Real engineers think about this way:

• If I want to use something that some library already wrote, I need to include its header
• Headers give you declarations, not implementations — but for things in the standard library, this is all you need to compile

So #include is not optional if you are using standard stuff like cout, vector, string, etc.

Angle Brackets vs Quotes #

You may see includes written in two ways:

#include <iostream>
#include "myfile.h"

• <iostream> means “look for this in system / standard locations”
• "myfile.h" means “look here in this project first, then check standard locations”

Standard library headers always use angle brackets (<>). That’s how the compiler knows these are built-in or installed with the toolchain.

Other Things Preprocessor Does #

You will encounter other preprocessor directives too, for example:

• #define — creates simple macros
• #ifdef, #ifndef, #endif — conditional compilation
• #pragma — compiler-specific instructions

We’ll talk about these in detail later when we deal with projects, build systems, and debugging nasty macro errors.

But for now, the most important thing is this:

Anything that starts with # runs before the compiler sees your C++ code.

So #include doesn’t do “C++ logic” — it just ensures the compiler sees the right declarations when it begins its real job.

Quick Note #

In big projects, you’ll start noticing that includes affect build times. If you include headers unnecessarily, your project compiles slowly. That’s when people start learning about:

• Forward declarations
• Include guards
• Precompiled headers

These concepts are all about managing what the preprocessor pulls in before the compiler starts.