Scope of Variables

• Global and local variables
  • Scope
    

    
    Think that a function is a building. Each building specialize on a certain function. Researchers collect data in the university, and a manuscript is submitted to a publisher. The manuscript is reivewed and edited in the publisher, and it may be returned to the university or published in a journal.

    Inside of a building, people (variables) are doing their own works. From each building, you can see other buildings. But you can't see through the people inside of the building (local variables). But you can see a person walking outside (global variables).

    Scope of a variable is where the variable is visible to other C code.
    Two main scopes in C: local scope and global scope

  • In C, the location of variable declaration determines the scope.

    Blocks (surrounded by { }) define the boundaries (walls of buildings).

    • Local variables:
      Declared in the beginning of a function (or a block).

      Visible to the function and to blocks inside of it.
      

    • Global vaiables:
      Declared outside all of the functions (space between function definitions).

      Generally declared before main().

      Visible to all functions, and can be modified in anywhere.

• Example

  #include <stdlib.h>
  
  double jesseJames;
  
  int main(void) {
    int buz = 2;
    jesseJames = 0;
    jesseJames = jesseJames + buz;
     :
  }
  
  int HardyP(double ms) {
    int john, daisy;
    jesseJames = 3;
     :
  }
  
  double HenryU(long long grant) {
    double polly;
    int i, john;
  
    for (i=0; i < 10; i++) {
      double data;
         :
    }
  }
  

• Why do we care about the scope of variables? (Pros and Cons)
  • Avoid name conflict.
    With local variables, the name has to be unique within the function.
    Names of global variables have to be unique within the program.

    When we say punch John in Henry Univ., the people in Henry Univ. know who he is. John in Hardy publisher won't be punched accidentally.

  • Easier to read the code because you only have to worry that the values are changed in the function (isolation of data).

    With global variable, it takes a lot of effort to know what jesseJames is going through in other functions.

  • With local variables, you have to pass the information to other function explicitely. This can become tedious.

    Global variables are good to store information relevant to all parts of the program.

  • Generally, I try to use local variables as much as possible.

• Initialization of variables
  • When local variables are declared, you don't know what value it has.
    Assign a initial value (initialize) before you use it.

    The following code is a bad example.

    int main(void) {
      int sum;
    
      for (i =0; i<5; i++) {
        sum = sum + i;
      }
      return 0;
    }
    

  • When global variables are declared, they are set to 0.
    Better to initialize any way, though.

• Function call revisisted.
  • When you call a function with arguments, you are passing the value of the arguments.

  • In the function, the value is copied to its own local variable.

  • If this value is modified within the function, it is local to the function. The value of the original variable is not modified.

  • Think following analogy:
    
    1. polly submit a manuscript to the publisher in pdf format.
    2. daisy prints out her own paper copy and add edits and comments.
    3. polly's original manuscript is not changed.
    4. daisy scan-in the edited copy and send it back to the university.
    5. daisy throw away the edited copy to the trash.
    6. Some comments are useful, so polly incorporate them to her own manuscripts.

• Confusing example: guess what the print out would be.

  #include <stdio.h>
  
  int func1(int bob, int buz)
  
  int main(void) {
    int bob = 3, buz =5;
  
    bob = func1(buz, bob)
    buz = func1(bob, buz)
  
    printf("value of bob is %d\n value of buz is %d\n", bob, buz);
  
    return 0;
  }
  
  int func1(int bob, int buz) {
    bob = 2 * bob + buz;
    return bob;
  }
  

• Exercises:
  1. A puzzler: explain what happens:

     #include <stdio.h>
     int gZ;
     
     void func(int x);
     
     int main (void) {
       gZ = 5;
       func(gZ);
       printf("gZ = %d\n", gZ);
     }
     
     void func(int x)  {
       x = 2;
       gZ += x;
     }
     

  2. Write a function which takes one integer as the argument and returns the absolute value of the integer.

  3. Make a function which immitates throwing a fair die. In other words, the function will return an integer value between 1 and 6 with equal frequency. Call this function from (inside of) main() 1000 times, and print out the average.

  4. You throw a die until you get ``1''. We want to count how many throws you'll need to get ``1'' Make a function which returns the number of throws required to get the first ``1''. Re-use the function you made above.

     Hint, you can make an infinite loop by for( ; ; ) { } (nothing other than 2 semi-colons in the parentheses), and use break; to get out from the loop when the condition is met. But there are several ways of doing this, so use whatever intuitive to you.

  5. You are going to flip a coin k times, and count the number of heads. Make a function which takes the number of coin-flipping trials (k) as the argument, and returns the number of heads. We have already made the CoinFlip() function which returns 0 (tail) or 1 (head for a single coin flip (code is in the section ``Function''). Your function should call CoinFlip() in such a way that it performs k coinflips, and then counts the number of heads, and return the number of heads.

  6. Now, modify the previous function (the new function you made in the exercise right above this), so that the coin can be biased. Let's call this new function BinomTrial(). In other words, p is the probability that the coin flip results in heads. The value of p for a fair coin is 1/2. Your new function should take two arguments (k and p), and should return the number of heads after k coinflips.

     From main(), call the BinomTrial() many times, and take the average number of heads. Confirm that the expected value is k p.

     (optional) calculate the variance. It should be close to k p (1-p).

     Hint: For a random variable X, variance can be calculated from:
     

     $$Var[X] = \frac{1}{k-1}\cdot \sum_{i = 1}^k \left(X_i - \bar{X... ...^k (X_i^2) - \frac{\left(\sum_{i=1}^k X_i\right)^2}{k} \right]$$
     
     

     In addition to keep track of sum of values from the every trials, you can use another variable to keep track of sum of squared values from the every trials.

  7. Write a function which takes an integer as an argument, It returns 1 when the integer is prime.

  8. Check what happens to the values of variable var.

     #include <stdio.h>
     
     int main ()
     {
       int var = 3;
     
       {
         int var = 5;
         printf ("Value w/i a block = %d\n", var);
       }
     
       printf ("Value outside = %d\n", var);
     
       return 0;
     }
     

  9. Can a program have a global and a local variable with the same name? Write a program to check this.