What is and how to use the FOR loop

A for loop is a control structure that repeats a block of code a specified number of times. It is one of the most commonly used control structures in C#.

The syntax of a for loop in C# consists of three main parts: initialization, condition, and update. These parts are specified within the parentheses of the for loop and are separated by semicolons.

The basic structure of a for loop in C# is as follows:

for (initialization; condition; update)
{
    // Instructions to be executed in each iteration
}

Let’s look at each of the parts

• Initialization: In this part of the loop, the initial values of the variables that control the loop’s execution are set. Typically, it is used to initialize a counter that will be incremented or decremented in each iteration.

• Condition: The condition is a boolean expression that is evaluated before each iteration. If the condition is true, the instructions inside the loop are executed. If the condition is false, the loop is exited, and the program’s execution continues.

• Update: In this part of the loop, an action is performed that modifies the value of the loop control variables. Typically, it is used to increment or decrement the counter.

• Instructions to execute: Here, the instructions to be executed in each iteration are specified. These instructions can be any valid C# code, such as assignments, calculations, method calls, etc.

Basic Example

Let’s look at a simple example where a for loop is used to print the numbers from 1 to 10:

for (int i = 1; i <= 10; i++)
{
    Console.WriteLine(i);
}

In this example:

• The initialization int i = 1 sets the initial value of i to 1.
• The condition i <= 10 ensures that the loop is executed as long as i is less than or equal to 10.
• The update i++ increments i by 1 after each iteration.
• Inside the loop, we use the Console.WriteLine() method to print the current value of i to the console.

The result is that the numbers from 1 to 10 will be displayed on the screen.

Modifying the loop flow

Skipping iterations with continue

The continue statement is used to skip the current iteration and proceed directly to the next iteration of the loop.

for (int i = 0; i < 10; i++)
{
    if (i % 2 == 0)
    {
        continue; // Skip the even numbers
    }
    Console.WriteLine(i);
}

Breaking out of the loop with break

Using the break statement allows exiting the loop before the condition is met. This is useful in situations where a specific value is found, and further iteration is not necessary.

for (int i = 0; i < 10; i++)
{
    if (i == 5)
    {
        break;
    }
    Console.WriteLine(i);
}

Special Cases

It is possible to perform more “original” cases of the For loop. In general, it is not a good idea to do it. But I’ll tell you, even if only so that if you ever see it, you scold someone. 😉

Use of external variables

It is possible to use a variable declared outside the for loop as the control variable. However, this can lead to confusion and errors if not managed properly:

int i = 0;
for (i = 0; i < 5; i++)
{
    Console.WriteLine(i);
}
Console.WriteLine($"Value of i after the loop: {i}");

In this case, i retains its value after the loop has finished, which will be 5.

Multiple declarations

In the initialization and update section, multiple declarations separated by commas can be included. This is useful when multiple control variables are needed:

for (int i = 0, j = 10; i < j; i++, j--)
{
    Console.WriteLine($"i: {i}, j: {j}");
}

Practical Examples

Generate a multiplication table

In this example, a multiplication table for a specific number is generated using a for loop.

int number = 5; // Number for which the multiplication table is generated

for (int i = 1; i <= 10; i++) // Iterate from 1 to 10
{
    Console.WriteLine($"{number} x {i} = {number * i}"); // Print the multiplication of the number by 'i'
}

Iterating over Arrays

One of the most common applications of the for loop is iterating over the elements of an array. Here’s an example that sums all the elements of an array:

int[] numbers = { 1, 2, 3, 4, 5 }; // Declare the array
int sum = 0; // Variable to store the sum

for (int i = 0; i < numbers.Length; i++)
{
    sum += numbers[i]; // Add each element of the array to 'sum'
}

Console.WriteLine($"The sum of the elements is: {sum}");

Iteration with a different step

The value of the update does not always have to be an increment of one. It can be any expression that modifies the control variable. For example, iterating in steps of two:

for (int i = 0; i < 10; i += 2) // Increment 'i' by 2 in each iteration
{
    Console.WriteLine(i); // Print the current value of 'i'
}

Decreasing for loop

The for loop can also be used to iterate in descending order:

for (int i = 10; i > 0; i--) // Decrement 'i' by 1 in each iteration
{
    Console.WriteLine(i); // Print the current value of 'i'
}

Finding an element in an Array

int[] numbers = { 1, 2, 3, 4, 5 }; // Declare the array
int search = 3; // Number to search for
bool found = false; // Variable to indicate if the number was found

for (int i = 0; i < numbers.Length; i++)
{
    if (numbers[i] == search) // Compare each element with the searched number
    {
        found = true; // Mark that the number was found
        break; // Exit the loop
    }
}

if (found)
{
    Console.WriteLine($"The number {search} is in the array.");
}
else
{
    Console.WriteLine($"The number {search} is not in the array.");
}