Scope and Lifetime

Objectives

1. Review the lifetime of variables
2. Explore static in function variables.

Notes

• The lifetime of a variable is when it is associated with memory.
• The scope of a variable is when the variable can be accessed.
• For these purposes I am going to introduce classes
  • A class is a compound data type.
    • It can hold multiple different types of data.
      • Heterogeneous, not homogeneous.
    • Accessed by name (not index)
    • With associated member functions.
  • Much more on this later.
  • Syntax:

    class identifier {
        public:
            // public methods and values
        private:
            // private methods and values
    };
            

  • For our use today, there are two member functions we are interested in
    • The class constructor is called when an instance of the class is created (or comes into lifetime).
    • The class destructor is called when an instance of the class is destroyed (goes out of lifetime).
    • The copy constructor is called when a pass by value occurs.
  • For our use this is enough.
• AliveT will
  • Give each new instance a unique id when it is created.
  • Print a message when a new instance is created.
  • Print a message when an instance is destroyed.
• Comments on lifetimeDemo.cpp
  • Ignore the class for now.
  • Instances 1 (a) and 2(b) are created when main starts.
    • The lifetime for these instances is the main code block.
    • Notice they are destroyed nearly last in the program when it exits.
    • Instance 12 is a special case we will discuss later.
  • Notice that the variable c is declared inside of the while loop.
    • We can see that this variable goes in and out of lifetime each iteration of the loop.
    • These are separate instances and share nothing.
  • You can declare a variable in the initialization of a for loop.
    • We see instance 7 is alive for ALL iterations of the for loop.
  • Probably should have done this before, but you can have stand alone code blocks.
    • Notice that variables inside the code block have lifetime of the code block.
  • Function calls:
    • Example 1, local variable, lifetime of code block.
      • Note a new copy is made each time the function is called.
    • Example 2, pass by value, makes a copy
      • The parameter has lifetime of the code block.
      • I didn't call this twice, but a new copy is made each time.
    • Example 3, pass by reference, no copy.
  • Function4 is special
    • In this context, static means extend the lifetime of this variable to the end of the program.
    • It will be initialized once.
    • It will maintain it's value every time the function is called.