Preprocessor Directives #include

Preprocessor directives are instructions that the compiler processes before compiling the code. These directives allow the programmer to include external resources or define preliminary configurations. One of the most commonly used directives is #include, which is used to include libraries needed for the program.

Using #include

The basic syntax to include a standard library is:

    #include <library_name>
    

The use of less-than and greater-than signs (< and >) tells the preprocessor to search for the library in the compiler’s standard directories. For example, to include the iostream library, which allows managing input and output operations, you use:

    #include <iostream>
    

Features of iostream

The iostream library contains classes and objects that facilitate the manipulation of data streams. Among the most common elements are:

• std::cin: Used for input data from the keyboard.
• std::cout: Allows output data to the console.
• std::cerr: Used to display error messages.
• std::clog: Provides a stream for logging messages.

Basic example using std::cin and std::cout:

    #include <iostream>
    int main() {
        std::string name;
        std::cout << "Enter your name: ";
        std::cin >> name;
        std::cout << "Hello, " << name << "!" << std::endl;
        return 0;
    }
    

Including Custom Libraries

To include libraries designed by the programmer, the same #include directive is used, but with a different syntax:

    #include "library_name.h"
    

The use of double quotes tells the preprocessor to first search for the library in the project’s current directory. If it is not found there, it will search in the standard directories.

Example of a custom library:

    // file "my_library.h"
    void greet() {
        std::cout << "Hello from a custom library!" << std::endl;
    }
    

    // main.cpp file
    #include <iostream>
    #include "my_library.h"
    int main() {
        greet();
        return 0;
    }
    

The Body of the Program: The main() Function

The main() function is the entry point of any C++ program. It is where the execution of the code begins, and its definition is essential for any functional program in this language.

Basic Definition of main()

The simplest way to define main() is:

    int main() {
        // This is where the program code is written
        return 0;
    }
    

In this definition:

• int: Specifies the data type that the main() function returns. In this case, int means the function must return an integer.
• return 0;: Indicates to the operating system that the program ended successfully. This value is known as the exit code, where 0 usually represents success, and other values can signal specific errors.

Why Use int as the Return Type?

The C++ standard specifies that the main() function must have an int (integer) return type. This is because the operating system needs a return value to determine the program’s status once it has finished. For example:

• A value of 0 indicates that the program finished successfully.
• A value different from 0 can be used to indicate specific errors.

Defining main() with a different return type, such as void, is possible in some compilers, but it does not comply with the C++ standard and may cause compatibility issues.

Don’t Forget to Comment Your Code

Comments are essential for documenting the code and making it easier to understand. Although they do not affect the program’s execution, they are useful for explaining the purpose or logic behind specific sections of the code. Commenting is especially important when the code has complex logic or has required intense design work. Never be deceived by the feeling of clarity when writing or reading your own code; that clarity can disappear entirely the next day. Writing your code should be as clear and clean as possible, and comments should serve as the necessary guide to preserve that clarity.

In C++, there are two main types of comments:

• Single-line comments:

          // This is a single-line comment
          

• Multi-line comments:

          /* This is a comment
             that can span
             multiple lines */
          

What to Do

• Add comments explaining the functionality of complex algorithms or parts of the program: This helps future readers, including yourself, quickly understand the implemented logic.
• Write comments in a way that is easy to understand for your peers: This is essential when working in a team or collaborative projects.

What to Avoid

• Using comments to explain or repeat the obvious: For example, it is not helpful to write // This line adds two numbers right above int sum = a + b;.
• Justifying unclear code with comments: While comments are important, the clarity of the code should always be the priority. Readable and well-structured code requires fewer comments to be understood.
• Not updating comments: When editing the code, ensure that the comments reflect the changes made. Outdated comments can cause confusion.