It must appear outside the loop or the output will be:

If you do not see this, as usual, TRACE it

And now that you are comfortable with the algorithm, here is the code:

// A program to calculate a sale prices based 
on a single discount  percentage and count the 
// number of items discounted 
// File: ch3prg2.cpp


// USE THE SPECIFICATIONS FROM THE PREVIOUS VERSION AND ADD A 
// DESCRIPTION OF THE COUNTER
#include <iostream.h>

const	double DISCOUNT = .87;

void main()
// Purpose: to calculate sale prices based on a single discount percentage and count the 
//              number of items discounted

// Receives:	NONE
// Returns:	NONE
	
{ 	  
	double price;
	double discountedPrice;
	   
         int itemCount = 0;
	      
         cout << "Please enter an item's original price (Enter -1 to Stop) ";
         cin >> price;

         while (price != -1) 
	 {
          	discountedPrice = price * DISCOUNT;
     		cout << "The New Price is: $" <<  discountedPrice << endl;
	        itemCount++;
		cout  << "Please enter an item's original price (Enter -1 to Stop) ";
             	cin >> price;
         }
         cout << itemCount;
}

before it was used. In other words, we could initialize the variable but it would be a waste of time since the initializing value would be lost.

Likewise a line that might be written:

could also be written as:

Now study the test condition:

Notice that it is clearly more complex than something like "(price != -1)". Its purpose is to handle the fact that a user can enter either an upper case or lower case 'Y'. What the test condition is saying is: "while the character entered is either an upper case 'Y' or a lower case 'y'...." continue the loop. The two vertical parallel lines (||) are the symbol for 'OR'. It is what we call a logical operator. There are two other very useful operators of this kind: '&&' is the symbol for AND while '!' is the symbol for NOT. All three of these can be used in any 'if' or 'while' test condition.

Their meaning is the same as in English. Therefore, "||" means that if EITHER of the individual conditions ("answer == 'Y'" or "answer == 'y'", in this code) are true, then the test as a whole is true. "&&" means that both conditions must be true - which would not make sense in this case since the memory location symbolized by 'answer' cannot contain 'Y' and 'y' at the same time. '!' means Not. In other words, if "(answer == 'Y')" is True then "!( answer == 'Y')" would be False. Note one can have multiple '||' operators in an expression, in which case, if any one of them is True, the combined expression is True. Likewise, you can have multiple '&& operators in an expression, in which case, only if all of the individual expressions is True, is the whole expression True. The issue of when and how to use and combine AND,s (&&), Or's (||) and NOT's (!)is very tricky. You should avoid mixing these unless you absolutely need to and are comfortable with logic. Chapter 6 has more discussion on how to decide when to use '&&' and when to use '||'.

Note the extra inner set of parenthesis in the test condition. They are technically not required but they do make the code easier to read. To see why they are not needed, we need to understand that logical operators (||, &&, and !) also have precedence rules just as arithmetic operators do. As a matter of fact all operators are part of the same precedence order. Here is the precedence table for all the operators we have seen so far:

the "==" operator (in both places) is executed before the "||" operator even without the inner set of parenthesis - which is as it needs to be for this to make sense. In other words, the system determines the truth of both equality tests and then does an OR operation. If either of the tests returns True, the whole expression is True so in this case, if 'answer' contains 'Y' or 'y' the expression is True. (If the precedence of "||" was higher than "==", this code, without the extra set of parentheses, would be asking the computer to do an OR on 'Y' and 'answer' - whatever that would mean!)

As a separate point, note that the '+' and '-' symbols appear twice in this table: in lines 2 and 4. In line 2 the '+' and '-' refer to the unary plus and the unary minus as in +5 and -5. Unary, of course, means 1 and in these two expressions there is only one value or operand. Contrast that with "3 - 5" or "value1+value2" where the '+' and '-' operators operate on two values or operands. In this case, '+' and '-' are binary operators. This particular precedence difference is rarely an issue in C++ so you can stop worrying about it but you should understand the basic difference between unary and binary operators.

This whole discussion was related to the Counter Pattern so a brief summary is in order.

1. The key to this pattern is contained in the two lines:

   Initialize the Counter Variable to 0
   Counter Variable++
   

2. This pattern usually is related to some loop pattern with this pattern sitting half inside and half outside the loop pattern.

3. If you had some reason to begin your counter at some value other than zero, that would be possible simply by initializing the counter variable (itemCount in the example here) to the other value. Usually counter variables are initialized to 0. However, if, for example, you already knew that 556 items had been counted and now wanted to count the rest, you might begin the above code fragment by initializing itemCount to 556 as in:
   

   int itemCount = 556;
   

4. If you wanted to count by some value other than one, for example, if you wanted to count by 5, you would change the line:
   count++ ; (or whatever counter variable you were using)
   
   to:
   
   count += 5; (or whatever value you wanted to count by).