Question

Suppose that the input is 38 35 71 14 -1. What is the output of the following code? Assume all variables are properly declared. sum = 0; cin >> num; while (num != -1) { sum = sum + num; cin >> num; } cout << "Sum = " << sum << endl;

Short answer

The output will be "Sum = 158".

Step-by-step solution

Understand the Input Sequence

The input sequence provided is 38, 35, 71, 14, -1. This sequence of numbers is to be processed by the given code snippet.

Read the First Number

The code begins execution by reading the first number in the sequence, which is 38. The variable `num` now holds this value.

Check the Condition

The code checks if `num` is not equal to -1. Since 38 is not equal to -1, the condition of the while loop is true, so we enter the loop.

Calculate Sum with First Number

Inside the loop, the current value of `sum` (which is initially 0) is updated by adding the current value of `num` (38). Thus, `sum` becomes 0 + 38 = 38.

Read the Next Number

The next number in the sequence, 35, is read by `cin >> num;`. Now, `num` holds the value 35.

Repeat the Condition Check

The condition `num != -1` is checked again. Since 35 is not -1, we remain in the loop.

Update the Sum Again

Add the current `num` (35) to `sum`. Now, `sum` is 38 + 35 = 73.

Read the Third Number

The next number, 71, is read into `num`.

Condition Check and Sum Update

Check `num != -1`; since 71 is not -1, we continue in the loop. Add 71 to `sum`: 73 + 71 = 144.

Read the Fourth Number

The next number, 14, is read into `num`.

Condition and Summation

Since 14 is not -1, the loop condition is true. Add 14 to `sum`, updating it to 144 + 14 = 158.

Read the Last Number

Read the final number, -1, into `num`. This is a sentinel value indicating the end of input.

Exit the Loop

Since the loop condition `num != -1` evaluates to false (because `num` is -1), the loop is exited.

Output the Result

The final `sum`, which is 158, is printed out as "Sum = 158".

Key concepts

Understanding the While Loop in C++

In C++, the `while` loop is a fundamental control structure used to perform repeated operations as long as a specified condition remains true. This loop checks a condition at the beginning of each iteration.
If the condition evaluates to true, the block of code within the loop will execute. If false, the loop terminates, and execution resumes after the loop. In our example, the while loop:

• Continuously reads an integer from input.
• Checks if the entered number is not equal to -1.
• Adds the number to a running total if the condition holds.

This loop continues until -1 is entered, at which point the condition fails, and loop execution ends.

How Sum Calculation Works

The process of calculating a sum in code involves accumulating values over several iterations. Here, we use a variable `sum`, initialized to 0, to hold the total of all numbers input before the sentinel value is encountered.
The steps for sum calculation include:

• On each iteration, check the condition (whether `num` is not equal to -1).
• If true, add the current number (value of `num`) to the `sum`.

This continues until all numbers are processed. At the end of the loop, the `sum` contains the total of all numbers entered, excluding the sentinel value. In the given exercise, the numbers 38, 35, 71, and 14 are summed to result in 158.

The Role of a Sentinel Value

A sentinel value is a special marker used to signify the end of a data stream in programming. It serves as a signal to stop further processing. In this exercise, the sentinel value -1 indicates when the input sequence finishes.
The program does not include -1 in the sum calculation, as its sole purpose is to terminate the loop. By checking the condition `num != -1`, the program effectively listens for this marker to know when to halt input reading and summing operations.
This approach not only clarifies when the input ends but also ensures that the summation logic accurately stops when all relevant numbers have been processed.

Step-by-Step Code Execution

Code execution follows a specific sequence from initialization to output in our example. The sequence is imperative for correctly executing the intended algorithm:
1. **Initialize**: Start with `sum` set to 0.
2. **Input Reading**: Begin reading numbers into `num`.
3. **Condition Evaluation**: Check if `num` is not -1. If it is, terminate the loop.
4. **Summation**: If the condition holds, add `num` to `sum`.
5. **Repeat**: Read the next number and repeat the condition and addition until a sentinel value (-1) is detected.
6. **Termination**: Upon reading -1, exit the loop.
7. **Output**: Print the final sum.
By following this sequence, the code ensures every step from reading to adding and finalizing output is handled seamlessly, leading to correct results.