Parameters and Local Variables

• A model to visualize variables and parameters.
• First a few reminders
  • A variable that is declared inside of a code block is local to that code block.
  • A variable that is declared outside of any code block is global.
  • DO NOT DECLARE GLOBAL VARIABLES
  • A parameter is listed in the function prototype.
  • A argument is listed in the function call.
  • In a pass by value only the value of the argument is passed to the parameter.
  • In a pass by reference the parameter and the argument are linked.
• Visualizing variables and parameters
  • A variable is just a location in memory.
    • I think of this as a box.

    • int age; 

    • 
  • A parameter is the same thing but
    • A value parameter is an independent box.
      • When the function is called, the value is copied from the argument into the parameter.
      • Then changes are made to the parameter box.
      • But these changes are not reflected in the argument box.

      • void Function1(int theAge);
        ...
        int main() {
           int age;
           ...
           Function1(age)
        }
        ...  

      • 
    • A pass by reference parameter is a linked box.
      • When the function is called, a "pointer" is established.
      • This is a box, but it tells the compiler to look to where it is pointing.
      • Changes in the parameter are actually made to the argument.
      • The parameter is just a redirection.

      • void Function2(int & newAge);
        ...
        int main() {
           int age;
           ...
           Function2(age)
        }
        ...  

      • 
  • A reference is a special type in c++, it was not in c.
    • Next semester we will learn about pointers and pass by pointer.
    • In 330 we discuss references in some detail.
    • But you are not really ready for any of that right now.
• Variables.
  • The lifetime of a variable is the time when a variable is available
    • This begins when the variable is declared.
    • And ends when the code block containing the variable is exited.
    • Lifetime can be extended with the static reserved word.
    • But please don't use this, it is not normally a good practice.
    • The lifetime of a parameter is the function.

    • void AFunction() {
          int localVar;   // lifetime of localVar begins here.
          // code
      
          while() {
              // localVar is still in lifetime
          }
          AnotherFunction();  // while AnotherFunction is executing localVar is still in it's lifetime.
      
          return;
          // lifetime of localVar ends here
      } 

  • The scope of a variable is the location in the code where a variable is available.
    • This is after the variable is declared
    • And for any code inside of the codeblock where the variable is declared.
    • Including nested code blocks.
    • The scope of a parameter is the function.

    • void AFunction() {
          int localVar;   // scope of localVar begins here.
          // code
      
          while() {
              // localVar is still in scope
          }
          AnotherFunction();  // while AnotherFunction is executing localVar is not in it scope.
      
          return;
          // scope of localVar ends here
      } 

  • In general:
    • lifetime is when a variable has a value.
    • scope is when a variable can possibly be used.
• Scoping rules
  • When the compiler needs to determine what variable to use, it looks
    • In the local code block.
    • If the variable is not in that block, then in the next enclosing code block.
    • If the variable is not in that block, then in the next enclosing code block.
    • ... until all nested code blocks are searched.
    • Then the global space.
  • Again, parameters are declared in the scope of the code block for the function.

    • void Function(int aParam){
          int aVar
      
          // aParam and aVar are in scope here.
          while() {
              int i;   // this goes against local convention.
      
              // aParam, aVar, and i are in scope here.
          }
          // i is no longer in lifetime or scope.
      }
               

  • Variables declared inside a for loop control structure
    • The following is legal

    • for(int i = 0; condition; increment) {
          body
      }
                    

    • The variable i is local to the loop.
      • It is only valid inside the body.
  • There are other situations
    • But in my mind, there are too many rules to worry about.
    • By only declaring variables at the top of each function, this is simplified.
    • By not nesting functions this is simplified.
  • The recent trend in c++ is changing this
    • Stroustrup believes that all variables should be initialized when declared.
    • From his C++ Core Guidelines
    • Don't introduce a variable (or constant) before you need to use it
    • Don't declare a variable until you have a value to initialize it with
  • For now, stick with the local convention.
• If we have two variables of the same name, both with active scopes, we experience name hiding or name shadowing

  • void Function(int aParam){
        int i{4} ;
    
        while() {
            int i{22};  
    
            // which i is used here?
            i = 7;
        }
        // which i is used here?
        cout << i
    }
    

  • Scoping rules tell us to use the "closest" one.
  • This is why we want all variables declared at the top of the function.
  • In the above, the in inside of the while loop hides the i declared in the main function.
• The terms scope and lifetime are very important in 230/330.