Scope and Lifetime

• We suddenly have more to discuss about identifiers.
• Scope: The region of the code where it is legal to reference an identifier.
• Lifetime: The period of time during program execution when an identifier has memory allocated to it.
• You have been taught to declare functions and constants in a global scope.
  • They are declared outside of any code block.
  • They have scope (are accessible) anywhere in the program.
  • They have lifetime (memory allocated) from when they are declared until the program exits.
  • This is not acceptable for variables.
• One of the strong programming tools is scope.
  • By maintaining when and where a variable can be changed we can trace the logic and determine when something has been changed incorrectly.
  • Scope and lifetime allow us to reduce where we need to look for bugs.
  • We know that a variable can only be changed:
    • If it is in scope.
    • Or if it was passed by reference.
  • By limited the scope we eliminate places the variable can be changed.
  • This is also why we pass by value whenever we can.
  • side effect occurs when one function has an impact on another function outside of the explicitly defined formal interface between them.
  • Side effect is hard to debug in larger programs.
• There are multiple different types of scope and lifetime, but let's just deal with functions, or even code blocks.
  • Part of this discussion will teach you new bad things.
  • Don't do them.
• In general
  • The scope of an identifier is from when it is declared until the code block containing its declaration ends.
  • The lifetime is the same with some exceptions.
  • But during function calls, local identifiers in the calling function go out of scope, but not lifetime.
• Parameters
  • Are in the scope of their function.
• Identifiers declared in control structures
  • Have the scope of the control structure.
  • Are questionable.

  • for (int i=0; i < 10; ++i) {
        // i is in scope and lifetime.
    }
    // i is out of scope and lifetime.

• Name hiding
  • When two identifiers have the same name and are in nested scopes.
  • The one with the most local scope takes precedence.
  • Don't do this.
  • The innermost is called a shadow variable.
  • -Wshadow warns of this.

  • int i;
    
    ...
    
    for(int i = ...) {
       // the i of the for loop is in scope and lifetime.
       // the i of the outer code is in lifetime, but not scope.
       
    }
    // the i of the for loop is gone.
    // but the reader can be confused about this.
    i = 5;

• Code blocks can be inserted within code.

  •  
    bool keepGoing;
    
    keepGoing = GetContinue();
    while (keepGoing) {
         string plainText;
         int shift;
         string criptText;
    
         plainText = GetMessage();
         shift = GetShiftAmount();
         cryptText = Encrypt(plainText,shift);
    
         PrintCode(criptText, plainText);
         keepGoing = GetContinue();
    }

  • In this case, the scope of the variables is within the loop.
  • This is questionable usage in my mind.