• To learn the different categories of memory
• To understand how to avoid common memory management errors
• To learn to write and use constructors and destructors
• To be able to create classes that manage their own memory allocation and deallocation

1. Code - instructions for all global and member functions
2. Static Data - global variables, and all local and member variables declared static
3. Run-time Stack - automatics (local non-static)
4. Free Store (Heap) - dynamically allocated (new)

• Contains all machine instructions for functions and methods
• May be referenced through pointers
  • (See next chptr. and Lippman[1] for discussion on function pointers)

• Globals, static locals and static member variables
• Size of statics can be known prior to execution
• Created only once
• Initialized only once, before main

• Used for functions
• Every call is a new activation record on stack
• Activation record contains:
  • Parameters
  • Return pointer
  • Local variables
  • Other machine-specific stuff
• Return from function decrements stack pointer
• Drawbacks:
  • Local variables cease to exist when function exits
  • Size of locals must be known at compile time

• Request storage area with new
• Values accessed through a pointer
• Neither the number of values, nor the size of a particular value need be known at compile time
• Lifetime of a value is not tied to a function
• Values may persist after program ends
• Space returned to heap using delete

• The programmer is responsible for memory management in C++
• Pointers can refer to memory in any of the four areas (above)
• Possible errors include:
  • Using a value that has not been initialized
  • Using a pointer to reference a memory location that is no longer valid (dangling pointer)
  • Forgetting to delete a dynamically allocated section of memory (memory leak)
  • Deleting a memory value that was never allocated
  • Deleting a dynamically allocated section of memory more than once

(introduced in Chptr. 6)

• Same name as the class
• No return type
• Used to initialize class' attributes
• May be overloaded
• Only one c'tor is invoked at creation
• Implicitly invoked:
• Each time a block is entered where an object is declared
• For static objects - before main starts
• When an object is created on the heap with new
• When an object is passed by value
• For member objects, when aggregate is created
• When child is instantiated

E.g., String class, with underlying array on heap.

class String
{
public:
   String(); // Default constructor
   String(const char p[]); // Simple constructor
   String(const String& right); // Copy constructor
   ~String(); // Destructor
   String& operator=(const String& right); // Assignment operator
   String& operator+=(const String& right);
   int length() const;
   char& operator[](int index);
   char operator[](int index) const;
private:
   char* buffer;
   int len;
};

• All constructors perform necessary initialization
• Example: Our c'tor must allocate space from heap and initialize:

  String::String(const char p[])
  {
     // Determine number of characters in string (strlen(p))
     len = 0;
     while (p[len] != '\0')
        len++;
     // Allocate buffer array, remember to make space for NULL character
     buffer = new char[len + 1];
     // Copy new characters (strcpy( buffer, p ))
     for (int i = 0; i < len; i++)
        buffer[i] = p[i];
     buffer[len] ='\0';
  }

  (Operators as described in chptr. 17)

• The constructor that takes no arguments
• Invoked without parenthesis, (except for unnamed temporaries
• Invoked:
  • When a variable is declared (or created from the heap) with no arguments
  • The only initializer for elements in an array
  • When object is member data of another class, and no initializer is provided

• Example: a String is, by default, an empty string

  String::String()
  {
     len = 0;
     buffer = NULL; // No need to allocate array to hold zero characters
  }

• Sole parameter is a const reference to an object of the same class
• Automatically supplied by compiler - memberwise (shallow) copy by default
• Calls copy c'tor of all member data
• Used to copy (clone) a value

• Example: each String has its own dynamically allocated buffer, so default behavior is insufficient. We extend this behavior:

  String::String(const String& right)
  {
     int n = right.length();
     buffer = new char[n + 1];
     for (int i = 0; i < n; i++)
        buffer[i] = right[i];
     buffer[n] = '\0';
  }

• Explicitly

  String first("Fred");
  String second(first); // second is initialized from first using copy constructor

• During initialization using =

String third = first; // Also uses copy constructor

• When an object is passed by value
• Note: Use const when passing a reference to avoid copy overhead

• Syntax only valid for constructors
• Used to avoid modifying an attribute twice (default c'tor, then in the body of the outer c'tor):

class Employee
{
public:
   Employee(String employee_name, double initial_salary);
   . . .
private:
   String name;
   double salary;
};

Employee::Employee(String employee_name, double initial_salary)
   : name(employee_name), salary(initial_salary)
{
}

• Necessary to invoke base-class c'tors; otherwise, the base-class' default c'tor will be called:

  class TeachingAssistant : public Employee
  public:
     TeachingAssistant(String student_name);
  };
  
  TeachingAssistant::TeachingAssistant(String student_name)
     // Teaching assistants all get same starting salary
     : Employee(student_name, 5000)
  {
  }

• Initializer lists must be used for:
  • Data fields declared as non-static const
  • References
  • To invoke a base class' c'tor (other than default)

• E.g., necessary when assigning a size to a vector member:

  class PartDescription
  {
  public:
     PartDescription(String part_name,
        int inventory_number);
  private:
     const String name;
     const int part_number:
     vector<PartDescription*> subcomponents;
  };
  PartDescription::PartDescription(String part_name,
        int inventory_number)
     : name(part_name), part_number(inventory_number),
        subcomponents(3) {}

• Tasks performed are similar to copy c'tor
• Must do cleanup first
• Check for auto-assignment

• Example: String class:

  String& String::operator=(const String& right)
  {
     if (this != &right)
     {
        delete[] buffer; // Get rid of old buffer
        len = right.length();
        buffer = new char[len + 1];
        for (int i = 0; i < len; i++)
           buffer[i] = right[i];
        buffer[len] = '\0';
     }
     return *this;
  }

• Perform necessary housekeeping tasks
• Named ~ClassName, no arguments, no return type
• Implicitly called on:
  • Local variables, at end of block
  • Parameters, at end of function
  • Temporary variables, at end of statement
  • Heap values, when delete is called
  • Static values, when main terminates
  • Member data, when object is deallocated
  • Base class object, when derived class object is deallocated
  • Local variables, when an exception is thrown and execution leaves the block

• Make destructors for base classes virtual
• E.g.: Consider the following declarations

  class Employee
  {
     virtual ~Employee();
  };
  
  Employee::~Employee()
  {  cout << "Goodbye Employee\n"; }

18.4 Virtual Destructors (cont.)

18.4 (cont.) "The Big 3" (revisit)

18.4.1 The Class auto_ptr

18.5 Reference Counting

18.5 Reference Counting

18.5 Reference Counting (cont.)

18.5 Example: Reference Counting

18.5 Example: Reference Counting (sharedString.cpp)

18.5 Reference Counting

18.6 Case Study: Matrices

18.6 Case Study: Matrices (matrix2.h)

18.6 Case Study: Matrices (matrix2.cpp)

18.6 Case Study: Matrices, (matrixtest2.cpp)

Chapter Summary