C++ Tutorial
C++ While Loop
while repeats as long as a condition stays true. Check that the condition can become false.
Repeat while a test is true
A while loop checks a condition, runs a block, then checks again. As long as the condition is true, the block repeats. When the condition is false, C++ leaves the loop and continues with the next statement.
Something inside the loop must change the values the condition looks at. If nothing changes, the test never becomes false and the program does not stop.
A complete while program
This loop prints 1 through 5. n starts at 1. Each pass prints, then adds 1. Whenn becomes 6, the condition is false and the loop ends.
Example
#include <iostream>
using namespace std;
int main() {
int n = 1;
while (n <= 5) {
cout << n << endl;
n = n + 1;
}
return 0;
}Compile this in /cpp/try. Then change 5 to another small number. Keep the increment. A missing n = n + 1 is how beginners create an infinite loop.
The three parts you manage
- Set a starting value before the loop.
- Write a condition that can become false.
- Update that value inside the loop.
Forget step 3 and the condition stays true forever. Forget step 1 and the condition uses garbage. Thefor loop in the next chapter packs these three into one line. while leaves them visible, which is useful when the update is not a simple + 1.
do while runs the body first
A do / while loop runs the block once, then checks the condition. If the condition is true, it runs again. The body always executes at least once, even when the test starts false.
Example
#include <iostream>
using namespace std;
int main() {
int n = 1;
do {
cout << n << endl;
n = n + 1;
} while (n <= 3);
return 0;
}Notice the semicolon after while (n <= 3). A do / while needs that semicolon. A plain while does not.
When the body should run first
Use do / while when the first pass must happen before you know whether to continue: print a menu, then ask whether to show it again. Use plain while when you might need zero passes: process input only while there is input left.
Example
#include <iostream>
using namespace std;
int main() {
int n = 10;
do {
cout << "ran once, n is " << n << endl;
} while (n < 0);
return 0;
}n is 10, so n < 0 is false, but the message still prints. A plainwhile (n < 0) would print nothing.
Infinite loops
while (true) never becomes false on its own. Neither does a loop whose counter never changes. The StudyGrid editor will sit there until a time limit cuts it off. Do not submit an example that cannot finish.
If the program never prints and never returns, look for a missing update. Count in your head: after enough passes, is the condition false? If you cannot say yes, the loop is unbounded.
A later chapter covers break, which can leave a loop early. Until then, make the condition do the stopping.
while versus for
| while | for | |
|---|---|---|
| Use when | You wait on a condition | You know the count |
| Counter | You set and update it yourself | Init, test, and step sit in one line |
| Zero passes | Yes, if the test starts false | Yes, same idea |
Next: the for loop, which is the usual choice for a known number of repeats.
Worked examples
The short listings above are there so you can see the grammar. The programs here use the same statements on quantities that already have units: a speed, a pH, a count of bases. They are classroom numbers. Air resistance is ignored. g is 9.81 m/s² unless a line says otherwise.
Open them in the C++ editor at /cpp/try. Change one measurement and check whether the result still has the right unit.
Physics
Half-life until the sample is small
Radioactive decay is exponential. Each half-life, on average, half the remaining nuclei have decayed. Starting at 8 g, three halvings leave 1 g.
while repeats until the mass drops below 1 g. Real decay is random; this is the deterministic envelope you sketch in class.
m = m₀ / 2ⁿ after n half-lives
Example
#include <iostream>
using namespace std;
int main() {
double mass = 8.0;
int steps = 0;
while (mass >= 1.0) {
mass = mass / 2.0;
steps++;
}
cout << "after " << steps << " half-lives: " << mass << " g" << endl;
return 0;
}Maths
How many times you can halve 64
64 is 2⁶. Dividing by 2 until you reach 1 takes six steps. That count is log2(64). The same idea underlies binary search: each step throws away half the remaining interval.
64 = 2⁶
Example
#include <iostream>
using namespace std;
int main() {
int n = 64;
int k = 0;
while (n > 1) {
n = n / 2;
k++;
}
cout << "log2(64) = " << k << endl;
return 0;
}