In a previous episode, we have discussed control statements, that is, C++ instructions letting data influence, choose or repeat, the executed processing. These control statements work along blocks. These blocks impact the use of variables. This impact is called the "scope of a variable" ; and this is what we will study in this episode. In C++, instructions can be regrouped within blocks, independently of any control statement. All it requires is a pair of curly braces bording a sequence of instructions. For example, we start a block here, declare an int-type variable called i declare a double-type variable called x, print a message asking the user to enter the values of x and i and finally printing the result on-screen. Now the closing curly braces signify the end of the block. In C++, blocks have much autonomy. They can delcare their own local variables, as we have seen previously. Local variables can even be declared in such a block, assiociated with an "if" instruction. For example, this variable j, used in this here block. This variable is local which means that once we reach the end of the block, we cannot use j anymore. A local variable can only be used in the block where it has been defined. Such a variable, defined in a block is called a local variable. The variable j, for example, is a variable local to this block here, controlled by the "if" instruction. Variables declared outside of any block, even outside the main - this is perfectly allowed - are called global variables. However, we will not give you examples of global variables. Indeed, a good practice rule is never to declare global variables, never ever! Why? Because, precisely, global variables are accessible from anywhere in the program. Thus, any instruction, anywhere in the program, can, for example modify this variable. It then becomes extremely tedious to keep track of the value of this variable. And that is why you are never to declare global variables. For that matter, we advise you to declare variables the closest to their utilization. In other words, the declaration line should be as close as possible to the line where this variable will be used for the first time. For example, in the previous "if" example, we had a variable j, we used inside the block of instructions controlled by the "if" and we had declared j in the previous block. Since j was not used in this section here, we should have moved this line closer to the variable's usage. j is only used in this block, and we assume that we do not use j anywhere else in the program. Therefore, such an instruction, declaring the variable outisde the block, does not follow the recommandation to declare as close to the usage as possible. We will thus move the declaration closer to the first instruction using j. Of course, we consider that j is only used within this block and nowhere else. This notion of the location where a variable can be used has a name: it is called the "scope of a variable". The scope of a variable is defined as all the lines of code where this variable is accessible; where we can use it. Let us take an example. We here have two nested "if" instructions, each one with its own block. Here the block of the first "if" instruction . And here the block of the second "if" instruction . In the block of the first "if "instruction, we declare a variable j. Thus, we can use this variable anywhere in the block where it has been declared. So, we can use j here, or here. We could also use it in this block here. However, once we exit the block concerned, we cannot, here, use j. Similarly, we will declare a variable k, here, closer to its utilization inside its own block. Thus, we can use k here, or here in this block. But we will not be able to use k afterwards. We say that the scope of k is this block here, the block where it has been declared. The scope of j is this block, where it has been declared. In C++, we can have variables with the same name but a different scope. Therefore, we need rules in order to know which variable we're talking about. Those are called the "scoping rules" (or "scope rules"). In C++, the scoping rule is very simple, we resolve to the nearest scope. Now what does it mean? Let us take an example We have two blocks, here. The first one is controlled by a higher level "if" instruction. Inside it, we declare a variable j. We will call it "j 1" or "red j". Here, we have a second block controlled by another "if" instruction. Inside it, we declare another j variable. By the way, this is not a very good idea and we do not advise you to adopt these practice in your programs. We're merely doing it here for explanation purposes. So, we have a second variable j; let's call it "j 2" or "blue j". The scope of this j is all the lines of code where it has been defined, declared, where it can be used. It is the block where it has been declared. The scope of the higher level j is all the lines of code where it is usable: it is the whole higher level block. So, in the deepest block - the blue block - the name j is ambiguous. Does it refer to the higher level j? Or does it refer to the lower level j? According to C++ scoping rules, we resolve to the nearest scope. Thus, j here refers to the j corresponding to the nearest block. The j that has been declared in this very block. The higher level j is perfectly valid here, but it is masked inside this block, and cannot thus be summoned. It will only reappear at the end of the block where "blue j" was declared. In the deepest block, "blue j" masks "red j". This was to illustrate the C++ scoping rules. However, what you should remember from this explanation is to avoid using multiple times, the same variable name: dodge ambuiguity. Indeed, we do not write programs for machines only. If this were the case, we would still write them in assembly language. We use "evolved" languages so that our fellow humans may understand, maintain, correct or transmit our programs. For that matter, avoid all ambiguity and strive to render your programs as clear as possible : do not call different things with the same name. A specific case of scope you should know is the scope of variables declared within an iterative loop, a "for loop". In this "for loop", we have declared a variable i. The scope of this i is the block controlled by the "for instruction", aswell as the condition and increment statement of the "for loop". However, the scope of i, does not reach any further. Starting from there, the variable i cannot be used anymore. Let us now finish with an example, which you should not encounter unless you call different things with the same name, which you shouldn't. This is merely to check if you are now familiar with the scoping rules. We have here a complete program. In the main, we declare an int-type variable i and intialize it to the value 120. Then comes a "for loop" iterating around a variable i, going from 0 to 5. We print the value of i in the loop. And, here, print the value of i at the end of the program. The question is: what does this program print? Let us examine the program step by step. First of all, we declare a variable i and initialized it to 120. Then, we enter the loop, declaring another variable i, initialized to 0. We test the condition: "i less than 5". Now which i is it? It is of course the i related to the loop; this i here. Thus, this value is indeed less than 5. We can enter the loop and print the value of i. Again, which i is it? The i with the closest scope is the i related to the loop, that is, this i here. Consequently, this line will print the value 0. Now we execute the increment statement. Once again, which i is it? Resolving to the closest scope, it is, as before, the i related to the loop. This i will thus go from 0 to 1, via this "++i" instruction. Now we retest the condition. We reach this line of code and test the condtion: "is i less than 5? " Yes. Thus, we print the value of i, that is still the i realted to the loop, which is 1. Now we execute the increment statement. i goes from 1 to 2. We test the condition again. It remains true. And we print the value of i, 2. And so on with 2, 3, 4. Now what will happen once i contains 4? We reach the increment statement, i goes from 4 to 5. The condition is now false. Indeed i is not less than 5, 5 is not strictly less than 5. Since the condition is false we exit the loop. We reach this point, at the end of the loop. Now we execute the instruction, following the loop, printing i. Which i is it, though? According to scoping rules, this i is the main. The i belonging to the level we're in. Do not forget that the i from the loop has its scope reduced to the loop. Thus, this i does not exist outside the loop. Therefore, the i we're talking about is the i from the main block. The starting i. It is now obvious that we will print 120.
