Structure of a C++ Program

A C++ program follows a specific, logical layout. Because C++ is a compiled language, the structure must be organized so that the compiler can understand what libraries to include, what memory to reserve, and where the execution should begin.

1. The Theory: From Source Code to Execution

A C++ program isn't just a list of instructions; it is a blueprint. The structure is designed to facilitate the Compilation Process. When you press "Run," the compiler reads your structure in a specific order:

1. Preprocessing: It looks for lines starting with #. These are instructions to the compiler to fetch external code (headers) before doing anything else.

2. Declaration: It identifies the names of variables and functions you intend to use.

3. Definition: It looks for the actual logic (the body of the code).

4. Execution: It looks for the main() function. In C++, main() is the unique entry point. No matter where it is placed in the file, the CPU will always start executing from the first line of main().

2. The Anatomy of a C++ Program

A standard C++ program is composed of five primary sections:

A. Documentation Section (Comments)

While not "code," this is the most important part for human collaborators.

• Single-line: Uses //.

• Multi-line: Uses /* ... */.

B. Preprocessor Directives

These commands tell the compiler to include necessary libraries. The most common is #include <iostream>, which stands for Input/Output Stream. It allows the program to use cout (to print) and cin (to read).

C. The using namespace std; Statement

In C++, a Namespace is like a library shelf. The standard library (std) contains many common tools.

• Without this line, you would have to type std::cout.

• With this line, you tell the compiler to look in the std shelf by default, allowing you to just type cout.

D. Global Declaration Section

Variables or functions declared here are accessible from any part of the program. However, in modern C++, global variables are generally avoided to prevent memory conflicts.

E. The main() Function

This is the heart of the program.

• int: The return type. It tells the operating system that the program will return an integer value when it finishes.

• { }: The curly braces define the Scope or the body of the function.

• return 0;: This signifies that the program has executed successfully. A non-zero return usually indicates an error.

3. A Practical Template

Here is how a standard program looks when all these theoretical parts are assembled:

// 1. Documentation: My first C++ Program
#include <iostream>        // 2. Preprocessor Directive

using namespace std;       // 3. Namespace Declaration

// 4. Global Declaration (Optional)
int globalVar = 100;

// 5. Main Function
int main() {
    
    // Local variable declaration
    int age = 20;

    // Executable statement
    cout << "Welcome to EMBLAb C++ Course!" << endl;
    cout << "Your age is: " << age << endl;

    return 0;              // Termination signal
}

4. Deep Dive into iostream and std

One of the most frequent questions in C++ theory is the difference between iostream and iostream.h.

• <iostream> (Standard): This is the modern, standard C++ header. It does not use the .h extension and requires the use of namespaces.

• <iostream.h> (Legacy): This was used in very old versions of C++ (pre-1998). If you use this today, your code will not be portable across modern compilers.

The "Standard" Namespace (std):

Imagine you have two different libraries that both have a function called print(). How does the compiler know which one to use? Namespaces solve this. By using std::cout, you are explicitly saying "use the cout from the standard C++ library."

5. Summary Table of Structural Components