We know that 'AreThereMore' will return true or false so it works well as the test condition. The loop will continue as long as there are more contracts to get. Note that there is no semicolon at the end of the line of code we just read although there is one just after this same code in the for loop itself. The semicolon in the 'for' loop is NOT part of the call. It is the sign to the compiler that there are no more test conditions. In chapter 8 we discussed how the 'for' loop can be coded to have more than one test condition. In the code we are discussing now there is only one test and there is nothing after the second semi-colon. Normally, this is where we would put any increments. The fact that there is nothing here indicates that there are no increments - at least none we need put here.

To see why this is so, we need to examine what goes on inside the loop. Part of the discussion about the interface of 'listOfContracts' must include a discussion of what will be expected of each public function - not 'how' each function will work but 'what' each function will do. In the case of 'GetNext', it needs to be decided if it will automatically handle somehow adjusting the instance to indicate the next contract, or if a special function needs to be called to do this. Some designs call for such a special function, with a name such as 'Continue' or 'Shift'. In our case, the fact that there is no addition member function in 'ListOfContracts' means that 'GetNext' must do the work. It will not only return the 'next' Contract, it will also adjust the data member 'next' to "point to" the contract after the one in the array just returned. Since this function does the work of adjusting 'next', there is no need for any incrementing or adjusting inside the 'for' statement parentheses.

Any part of a 'for' statement can be excluded. Here is an interesting version:

for (int j = 0; ;i++ )
{

cout << j << endl;
}

	void  ListOfContracts :: Reset()
	{ next = 0;
	}

	Contract  ListOfContracts :: GetNext()
	{
		return listOfContracts[next++];
	}

	bool  ListOfContracts :: AreThereMore()
	{	if (next < numContracts)
		{	return true;
		}
		else
		{	return false;
		}
		// More complex: the single line: return (next < numContracts)
	}

the value would be incremented first and then output. So, if 'var1' started with the value 3, that value would be incremented to 4 and 4 would then be output. To summarize: a "++" before a variable means to increment the value in the variable and then, if something is to be done, do it; a "++' after a variable means to do anything that is to be done with the value in the variable and then increment it. When the '++' is before the variable, we are using the prefix operator, and when the '++' is afrer the variable, we are using the postfix operator.

Note that when we have the variable with the "++" by itself as in

index = 0;
while (index < 10)
{

// some code
index++;
}

In neither case is the incremented value being used right away.

The same discussion is relevant to the "--" operator. The code

would cause the value in 'index' to be output before the value is decremented. But,

will cause the value to be decremented before it is output.

the system will retrieve the contract in the array element indicated by the value in 'next' before it is incremented; 'next' will then be incremented; and finally, the retrieved contract is returned. The 'return' makes it a bit difficult to see what is happening so consider the following code which will have exactly the same effect:

Contract c1;
c1 = listOfContracts[next++];
return c1;

and returns true or false depending on the answer. Note the comment at the end of the function indicating a more complex way of writing the code:

This says to directly return the result of the comparison. The code "next < numContracts" will return 0 if it is not true and some value other than 0 if it is true. The word 'return' will then cause this value to be returned to the calling function. Feel free to use this variation of the code if you feel comfortable with it but both approaches are the same. It is presented here so that you will have some idea of what is going on if you encounter this form as you read other code - which you are, of course, doing at every opportunity you have - if you really want to learn to code!

That completes the discussion of iterators. To see this code run, you can use the same version of class 'Contract' (contrct4.h and contrct4.cpp. Here are the complete versions of the modified code for 'ListOfContracts' (ch10lst5.h and ch10lst5.cpp) and the main program (ch10tst7.cpp)

Topics Covered in the "Essentials of C++"

Top of Section

Main Menu

Next Section