The easiest loop to understand is one that runs a fixed number of times, such as 10 or 20 times. By defining exactly how many times you want a loop to run, you can ensure that the loop always ends eventually.

To create a loop that runs a fixed number of times, you use a for statement, which looks like this:

int countingVariable
for (initialValue; BooleanExpression; incrementExpression)
{
    instructions;
}

A for statement consists of four items:

The counting variable is defined as an integer before the loop and is used to keep track of how many times the loop has run.

The initial value defines the number that the counting variable is set to when the loop starts. Usually this initial value is 0 or 1, but it can be any value.

The Boolean expression defines when the loop will run. The loop will stop after the counting variable has reached a certain value, such as 4. That means the loop might run four times (depending on its initial value).

The increment expression defines how the counting variable changes. Usually the counting variable changes by 1, but you can define this increment change by any number such as 2, 4, or even a negative number like −3.

To see how to create a loop using the for statement, follow these steps:

In this example, the counting variable is i, the initial value is i = 0, and the Boolean expression is i < 5. That means as long as this Boolean expression evaluates to YES (where i is a value less than 5), the loop keeps running. As soon as the Boolean expression i < 5 evaluates to NO (where the value of i equals 5 or greater), then the loop stops.

The increment expression is i++, which is a shortcut for i = i+ 1. The i++ increment expression simply counts by 1. If you wanted to count by a different value, you could replace the i++ expression with something else such as i = i + 4.

The for loop currently runs exactly five times, but you could create a loop that runs five times by using different initial values, Boolean expressions, and increment expressions. For example, this loop also runs five times:

int i;
for (i = 105; i > 100; i--)
    {
        NSLog (@"The value of i = %i", i);
    }

If you modify the VariableTest program with this loop, the output looks like this:

2010-08-29 17:31:56.230 VariableTest[12128:a0f] The value of i = 105
2010-08-29 17:31:56.237 VariableTest[12128:a0f] The value of i = 104
2010-08-29 17:31:56.238 VariableTest[12128:a0f] The value of i = 103
2010-08-29 17:31:56.239 VariableTest[12128:a0f] The value of i = 102
2010-08-29 17:31:56.240 VariableTest[12128:a0f] The value of i = 101

In this case, the loop is counting backward from 105 down to 101. The i-- increment expression is equivalent to i = i - 1.

By changing the initial value, the Boolean expression, and the increment expression, you can define how many times you want the loop to run.

int i;
for (i = 0; i < 5; i++)
    {
        instructions;
        if (passwordValid)
          {
              break;
          }
    }

int i;
for (i = 0; i < 5; i++)
    {
        if (Boolean expression)
          {
              continue;
          }
        instruction1;
    }

Sometimes you may need a loop to run based on an outside condition that you can't predict ahead of time. Other times you may not want the loop to run even once depending on outside conditions. In both of these cases, you need to choose a different type of loop, either a while loop or a do-while loop.

while (Boolean expression)
    {
        instructions;
        instructions that can change Boolean expression;
    }

do
    {
        instructions;
        instructions that can change Boolean expression;
    } while (Boolean expression);

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
    int i;
    i = 0;
    do
    {
        NSLog (@"The value of i = %i", i);
        i++;
        if (i == 2)
        {

break;
        }
    } while (i < 5);
}

2010-08-30 20:12:20.535 VariableTest[15016:a0f] The value of i = 0
2010-08-30 20:12:20.537 VariableTest[15016:a0f] The value of i = 1

- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
    int i;
    i = 0;
    do
    {
        i++;
        if ((i % 2) != 0)
        {
            continue;
        }
        NSLog (@"The value of i = %i", i);
    } while (i < 5);
}

2010-08-30 20:22:51.675 VariableTest[15138:a0f] The value of i = 2
2010-08-30 20:22:51.683 VariableTest[15138:a0f] The value of i = 4

Loops typically contain one or more instructions arranged sequentially. However, it's possible for a loop to contain instructions organized in a branch or even another loop. When one loop appears inside another loop, that's called a nested loop, an example of which is shown in Figure 7-1.

Figure 7-1. A nested loop occurs when one loop appears inside of another one.

When one loop is nested inside another one, the inner loop must always finish running first before the outer loop can finish. The inner loop can even change the Boolean expression that the outer loop depends on, but if you try this, make sure that the outer loop eventually ends or you risk creating an endless loop.

It's possible to nest a while loop inside a for loop, or vice versa. Although there's no limit to the number of loops you can nest within one another, each nested loop makes understanding how the program works more difficult, which could result in unpredictable behavior if you incorrectly modify any code inside any of the nested loops. Use nested loops only when absolutely necessary to make your programs easier to understand.

To see how nested loops work, follow these steps:

Both the inner and outer loops run exactly three times. However, notice that the inner loop repeats multiple times, but the outer loop runs only once.

Loops represent the third basic building block for creating programs, in addition to sequential instructions and branches. Loops run one or more instructions repetitively. The two types of loops you can create are for and while loops.

Use the for loop when you know exactly how many times you want to run a loop. Use a while loop or do-while loop when you don't know how many times a loop should repeat, so that your program can adapt to outside circumstances.

If you want a loop to run zero or more times, use the while loop. If you need the loop to run at least once, then use the do-while loop. With both the while loop and do-while loop, you must change the Boolean expression inside your loop. If you fail to change the loop's Boolean expression, you risk creating an endless loop.

For greater flexibility, you can nest loops inside one another. Since nested loops can be harder to understand, use nested loops sparingly. Just remember that the inner loop must always runs first before the outer loop can finish.

Loops enable your program to run one or more instructions repetitively. Although loops can eliminate the need to write multiple lines of identical (or nearly identical) instructions, loops do make your programs harder to understand. Combining loops with sequential instructions and branches allows you to create virtually any type of program you wish.