Вы находитесь на странице: 1из 5

Loops (C++)

1
Loops (C++)
Loops allow a programmer to execute the same block of code repeatedly. We will make heavy use of conditional
statements in this section.
The while Loop
The while loop is really the only necessary repetition construct. The for loop, coming up, can be duplicated
using a while loop, and with more control. A simple negation can perform the same behavior as an until loop.
The syntax is as follows:
while ( condition ) {
//body
}
Again, the curly braces surrounding the body of the while loop indicate that multiple statements will be executed as
part of this loop. If the actual code looked something like this:
while ( x == 4 ) while ( x == 4 ) {
y += x; means y += x;
x += 1; }
x += 1;
There would be a problem. According to what was written, even though the second line after the while was
indented, only the first line corresponds to the while loop. This is a huge problem because the variable involved in
the condition (x) does not change, so it will always evaluate to true, making this an infinite loop. This could be
alleviated by containing all statements intended to be a part of the loop body in { }.
while ( x == 4 ) {
y += x;
x += 1;
}
The do...while Loop
The do...while loop is nearly identical to the while loop, but instead of checking the conditional statement
before the loop starts, the do...while loop checks the conditional statement before continuing onto another
iteration.
The syntax is as follows:
do {
//body
} while (condition);
As you can see, it will run the loop at least once before checking the conditional.
The do...while loop is still haunted by infinite loops, so exercise the same caution with the do...while
loop as you would with the while loop. Its usefulness is much more limited than the while loop, so use this only
when necessary.
Loops (C++)
2
The for Loop
The for loop is a while loop that lets a programmer control exactly how many times a loop will iterate.
The syntax is as follows:
for (<i>expression for initialization</i> ; <i>expression for testing</i> ;
<i>expression for ''re''initialization</i>) {
//body
}
Here is an example of how the for loop works:
for ( int i = 0; i < 10; ++i ) {
std::cout << i << std::endl;
}
The code above and below are more or less equivalent.
{
int i = 0;
while ( i < 10 ) {
std::cout << i << std::endl;
++i;
}
}
What does this loop do? Prior to the first iteration, it sets the value of i to 0. Next, it tests (like a normal while
loop) if i is less than 10. If the statement returns true, the body of the loop is run and the program will print the
value returned by the simple arithmetic statement i+1 and move the terminal cursor down to the next line. After the
loop is finished, i is incremented (by 1), as specified in the update statement, and the conditional is tested again.
So, this loop will run a total of 10 times, printing the "i+1" each time. You've taught your program to count!
The variable used in for loops is generally an integer variable named i, j, or k, and is often initialized prior to the
beginning of the for loop. Another option is to initialize the variable at the same time that you declare the
variable's initial state:
for (int i = 0; i < 10; i++) {
cout << i+1 << endl;
}
If this is done properly, it is possible to nest for loops.
int input;
cout << "How many missiles will you fire?" << endl;
cin >> input;
cout << endl;
for (int i = 0; i < input; i++) {
for (int j = 10; j > 0; j--) {
cout << j << " ";
}
cout << "Missile " << i+1 << " has launched." << endl;
Loops (C++)
3
}
cout << "All missiles have been launched." << endl;
What does this program do? The user is prompted to choose an integer, which is used in the conditional statement of
the first for loop. Each iteration of the i loop will cause the j loop to run, which counts down from 10 to 1 before
allowing the i loop to continue. The output will look something like this:
How many missiles will you fire?
3
10 9 8 7 6 5 4 3 2 1 Missile 1 has launched.
10 9 8 7 6 5 4 3 2 1 Missile 2 has launched.
10 9 8 7 6 5 4 3 2 1 Missile 3 has launched.
All missiles have been launched.
Equivalence of C++ Looping Structures
The while loop can take the place of do...while loops if the condition for the while loop is "rigged" to be
true at least the first time around.
The while loop can take the place of until loops by negating the condition that would be specified for the
until loop, as explained above.
For and While loops
A for loop is structured as follows:
for (<initial expression> ; <condition> ; <update expression>) {
<block of code>
}
This can easily be reformatted as (do recognize the extra enclosing brackets, and the two extra semicolons after the
expressions in order to turn them into statements):
{
<initial expression> ;
while (<condition>) {
<block of code>
<update expression> ;
}
}
A for loop is more often used in by C++ programmers due to its conciseness as well as its separation of the
looping logic (often using a loop control variable like "int i" or another simple iterator) from the loop's content. A
while loop is often preferred if the initial statement or update statement requires more complex code than fits
neatly into a the for construct. However, the two are fully equivalent therefore it is ultimately a coding style
decision, not a technical decision whether to use one or the other.
Loops (C++)
4
Infinite Loops
One common programming mistake to create an infinite loop. An infinite loop refers to a loop, which under certain
valid (or at least plausible) input, will never exit.
Beginning programmers should be careful to examine all the possible inputs into a loop to ensure that for each such
set of inputs, there is an exit condition that will eventually be reached. In addition to preventing the program from
hanging (i.e. never finishing), understanding all potential inputs and exit conditions demonstrates a solid
understanding of the algorithm being written. Academic studies of programming languages often test students' ability
to identify infinite loops for the very reason that doing so often requires a solid understanding of the underlying
code.
Compilers, debuggers, and other programming tools can only help the programmer so far in detecting infinite loops.
In the fully general case, it is not possible to automatically detect an infinite loop. This is known as the halting
problem. While the halting problem is not solvable in the fully general case, it is possible to determine whether a
loop will halt for some specific cases.
Where To Go Next
Topics in C++
Beginners Data Structures Advanced
Lesson 1: Introduction to C++ Lesson 8: Pointers Lesson 12: The STL
Lesson 2: Variables and User Input Lesson 9: Classes and Inheritance Lesson 13: STL Algorithms
Lesson 3: Simple Math Lesson 10: Templates 1
Lesson 4: Conditional Statements Lesson 11: Templates 2
Lesson 5: Loops
Lesson 6: Functions and Recursion
Lesson 7: More Functions
Part of the School of Computer Science
Article Sources and Contributors
5
Article Sources and Contributors
Loops (C++) Source: http://en.wikiversity.org/w/index.php?oldid=617677 Contributors: Autumnfields, Captain Vandal, Chyld989, Elusive Pete, Gbaor, HappyCamper, MichaelFrey, Miklcct,
Pnguyen, Prohlep, Relin, Remi, Shatner, 9 anonymous edits
License
Creative Commons Attribution-Share Alike 3.0 Unported
//creativecommons.org/licenses/by-sa/3.0/