3. Declaring & Assigning Variables

Lesson: The Lifecycle of a Variable

Variables go through a lifecycle in your program. Each stage reflects what the compiler is told to do, either explicitly in your source code or implicitly by the language. Understanding this lifecycle is essential for writing correct and efficient code.

There are four distinct actions:

1. Declaration – An identifier is associated with a particular type.
2. Instantiation – Memory is reserved for the identifier.
3. Assignment – A value is placed into that memory.
4. Release & Deletion – Memory is freed, and the variable ceases to exist.

For example, in C++:

int x;        // Declaration + Instantiation (memory reserved for an int)
x = 5;        // Assignment (value written into memory)
              // At end of scope, memory is released and x is deleted

These steps can be combined:

int x = 5;    // Declaration + Instantiation + Assignment

The release of memory and deletion of the variable happen automatically when the program leaves the block in which the variable was declared (when the closing } is reached).

Explicit vs Implicit Memory Management

In the example int x;:

• Declaration is explicit: you tell the compiler “x” is an integer.
• Instantiation (memory reservation) is implicit: the compiler automatically reserves memory.
• Release of memory is also implicit: when x goes out of scope, its memory is freed without you writing anything.

This implicit behaviour prevents many errors, because the compiler enforces rules: you cannot use x after it is deleted.

Common Errors in the Lifecycle

Novice programmers often misuse variables at the wrong stage:

• Reading before instantiation: e.g., using x before giving it a value.
• Reading after release: e.g., trying to access x after the scope has ended.

When a variable is declared and assigned properly, these errors are avoided. For example:

// Bad: using x before assignment
int x;
cout << x;   // undefined behaviour (uninitialised read)

// Good: initialise immediately
int x = 42;
cout << x;   // safe and correct

Summary

Variables aren’t just “storage boxes.” They follow a strict lifecycle: declaration, instantiation, assignment, and release/deletion. Errors occur when you try to manipulate them outside of the correct stage. Good programmers respect this lifecycle, initialise variables carefully, and rely on scope to manage memory safely.

Mini Exercise — Trace, Fix, and Safeguard Variable Lifecycles

Goal: practise identifying each lifecycle stage (Declaration → Instantiation → Assignment → Release/Deletion), fix common mistakes (use-before-init, use-after-release), and choose safe patterns (scope, const, RAII).

1. Label the lifecycle
   For each identifier below, mark where it is declared, instantiated, assigned, and released/deleted. Note stack vs heap.

   #include <iostream>
   using namespace std;
   
   int main() {
       int n;                    // 1)
       if (true) {
           int n = 3;            // 2) (shadows outer n)
           int* p = new int(n);  // 3) pointer + heap object
           *p += 1;              // 4)
           cout << *p << "\n";
           delete p;             // 5)
       }                         // 6)
       cout << n << "\n";        // 7)
   }
   

   • Explain what is released at (5) vs (6). What happens at (7) if outer n was never assigned?
   • Rewrite so outer n is safely initialised and no shadowing occurs.
2. Fix dangling returns
   Identify the lifecycle error(s). Refactor to a safe design (return by value, or use RAII like std::unique_ptr).

   int* makeVal() {
       int x = 42;
       return &x;      // ❌ returns address of a dead stack variable
   }
   
   int& pick(bool b) {
       int a = 1, c = 2;
       return b ? a : c;  // ❌ returns reference to dead locals
   }
   

   • Provide two fixes for makeVal (value-return and RAII pointer).
   • Rewrite pick so it is safe and communicates ownership clearly.
3. Halt use-after-release & mismatched delete
   Find the bugs, then rewrite using RAII containers.

   int main() {
       int* p = new int{5};
       delete p;
       std::cout << *p << "\n";   // ❌ use-after-free
   
       int* q = new int[3]{1,2,3};
       delete q;                 // ❌ wrong deallocator (should be delete[])
       // ...
   }
   

   • Correct the manual version (delete[] q;, nulling pointers, etc.).
   • Refactor to std::unique_ptr<int[]> or std::vector<int> so release is implicit.
4. Scope, shadowing, and const
   Eliminate shadowing and tighten scope. Mark immutable values const.

   int count = 10;
   for (int i = 0; i < count; ++i) {
       int count = i;    // ❌ shadows outer 'count'
       // ...
   }
   

   • Rename variables to avoid shadowing; limit the lifetime of loop-local variables.
   • Which identifiers can be const, and why?
5. Predict construction/destruction (release points)
   Predict the exact output order (line by line) and annotate where each object is destroyed.

   #include <iostream>
   #include <string>
   struct Trace {
       std::string name;
       Trace(std::string n): name(std::move(n)) { std::cout << "+" << name << "\n"; }
       ~Trace() { std::cout << "-" << name << "\n"; }
   };
   
   int main(){
       Trace a("a");
       {
           Trace b("b");
           {
               Trace c("c");
           }
       }
   }
   

   • Now add a heap allocation inside the inner block and manage it with std::unique_ptr<Trace>. When is the heap object released?
6. Guard the lifecycle
   Strengthen the examples with safe initialisation and checks.
   • Add a precondition for counts/lengths (e.g., handle n == 0 before division).
   • Prefer initialising declarations (int maxVal = std::numeric_limits<int>::min(); or “first-element” strategy).
   • Replace raw pointers with RAII; rely on scope to drive deletion.

int attempts{3};       // direct-list-initialisation
int copies = attempts; // copy-initialisation
int uninitialised;     // no initialiser for a local fundamental object

#include <iostream>

int main() {
    int remainingLives{3};
    std::cout << "Initially: " << remainingLives << '\n';

    remainingLives = 2;
    std::cout << "After assignment: " << remainingLives << '\n';

    {
        const int bonusLives{1};
        remainingLives = remainingLives + bonusLives;
    }

    std::cout << "After the block: " << remainingLives << '\n';
}