Advanced Programming II Class Notes

Lecture Notes for Advanced Programming II

25 March 2004 - Dynamic Memory and Classes

Outline

Statically Allocated Memory
Dynamic Memory and Classes
- Destructors
- Copy Constructor
- Assignment
  - The Self-Assignment Problem
  - Assignments as Expressions
  - Assignment vs. Copying
The Rule of Three

Dynamic Memory and Classes

Many classes implement dynamic data structures - variable sized data
If at all possible, use the STL.
- It's all taken care of for you.
- But, may be expensive in time and space, may not be possible or easy.
The other possibility is to use dynamic memory.
- But not necessarily new and delete.
Dynamic memory and classes are not a match made in heaven
- Three class specific problems - destructors, copying, and assignments.
- Worse than dynamic memory and exceptions; leaks o' plenty.

Use Statically Allocated Memory

Use a big-enough array to hold the data.
- Grossly over-estimating the worst case size.
- It wastes space, but so what?
Good for small amounts of data with small variability.
- The more data, the more waste.
- Highly variable data may be too big too often.
Space inefficient, but implementation- and run-time efficient.
- However, run-time costs include virtual memory behavior.
Not flexible, but safe with proper checking.
- Make sure you do the checking.
- This is a dangerous form of program design.
Also known as pre-allocation.

Static Allocation Example

Compute statistics for everyone at Monmouth.
- Assumption: the data set is small and slowly varying.
- Around 6,000 students.
- Double for the administrators - 12,000 total.
- Double it to be safe - 24,000 total.
```
const unsigned mu_population = 24000;
static personnel_record[mu_population];
```
- Around 5 meg at 200 bytes/record.

Another Static Allocation Example

But I did that and you took off 30 points.
- Here's what you did.
```
char line[100];
while (cin >> line) { ... }
```
- Here's the problems.
  - Poor size estimate - 100 is too small.
    - A judgment call.
  - No checking - input buffer overflow.
    - use cin.getline(line, 100).
  - Poor coding - the magic number 100.
    - Use const unsigned ln_size = 100.
  - Strings do this job easier and better.
Static allocation is easy to get wrong and hard to get right.

Class Destructors

Where garbage comes from:

struct C {
  data * data_ptr;
  C() : data_ptr(new data) { }
  };

static void t(void) { C c; }

This code violates the fundamental rule of dynamic memory:
If you allocate it, you free it.

The class destructor frees class-allocated memory.

struct C {
  data * data_ptr;
  C() : data_ptr(new data) { }
 ~C() { delete data_ptr; }
  };

static void t(void) { C c; }

Destructor management - simple, effective, necessary.
No need to check for NULL - a question of style

Class Instance Copying

By default, base-type values are bit-wise copied.

This replicates pointers, leading to un-intentional sharing and dangling pointers on destruction.

struct C {
  data * data_ptr;
  C() : data_ptr(new data) { }
 ~C() { delete data_ptr; }
  };

static void t(C & c) { C local_c(c); }

In t(), local_c.data_ptr is c.data_ptr.
- Changes to *(local_c.data_ptr) change *(c.data_ptr).
- Deleting *(local_c.data_ptr) deletes *(c.data_ptr).
Class instance copying happens all the time.
- For example, non-reference class parameters.
```
void t(C c) { }
```
  The call t(c) makes a copy of c.

The Copy Constructor

Use the class copy constructor to handle dynamic memory copying.
The copy constructor prototype is
C::C(const C &).
- Don't forget the reference &.

The details depend on the memory being managed.

struct C {
  data * data_ptr;

  C() : data_ptr(new data) { }

  C(const C & c) 
    : data_ptr(data_clone(c.data_ptr)) {}

 ~C() { delete data_ptr; }
  };

static void t(C & c) { C local_c(c); }

Generically, copy management is known as cloning.
- Need to store enough information somewhere to clone the memory.

Class Instance Assignment

Instance assignment is similar to instance copying.
The default base-type assignment is bit copying.
- This leads to unintended sharing, dangling pointers, and garbage.

For example,

struct C {
  data * data_ptr;

  C() : data_ptr(new data) { }

  C(const C & c) 
    : data_ptr(data_clone(c.data_ptr)) {}

 ~C() { delete data_ptr; }
  };

static void t(C & c) { C local_c; local_c = c; }

The contents of c.data_ptr replaces the contents of local_c.data_ptr.

The previous contents of local_c.data_ptr is garbage.
local_c.data_ptr and c.data_ptr are sharing memory.

The Assignment Operator

Classes should define an assignment operator to manage memory during assignments.

Dynamic memory management is simple:

Deallocate memory in the instance to the left of the =.
Clone memory from the instance to the right of the =.

struct C {
  data * data_ptr;
  C() : data_ptr(new data) { }
  C(const C & c) : data_ptr(data_clone(c.data_ptr)) {}
 ~C() { delete data_ptr; }

  C & operator = (const C & c) {    // Bad example.
    delete data_ptr;
    data_ptr = data_clone(c.data_ptr);
    return *this;
    }
  };

static void t(C & c) { C local_c; local_c = c; }

Assignment and copy constructors usually can share code.
- Duplicate code is bad code.
Two tricks to assignment - self assignment and the assignment expression.

The Self-Assignment Problem

a = a self-assignment does occur in code.
- Particularly with references and parameters.
- This is a source of nasty errors.

What's could happen with a = a?

struct C {
  data * data_ptr;

  C & operator = (const C & rhs) {
    delete data_ptr;
    data_ptr = copy_data(rhs.data_ptr);
    return *this;
    }
  };

Deallocating in lhs also deallocates in rhs.

For a = a, *this = rhs.
Deleting data_ptr deletes rhs.data_ptr.

Solving the Self-Assignment Problem

Make sure *this is different from rhs.

If *this and rhs are different, proceeds as normal.
If *this and rhs are the same, be careful.

struct C {
  data * data_ptr;

  C & operator = (const C & rhs) {
    if (this != &rhs) {
      delete data_ptr;
      data_ptr = copy_data(rhs.data_ptr);
      }
    return *this;
    }
  };

Assignments as Expressions

A little-known C++ fun fact: an assignment is an expression.
- x = y = z = 0.0;
- The value of an assignment is the value on the right.
Overloaded assignment should support this behavior.
- Programmers may expect this behavior from assignment.
- Good programmers don't disappoint their colleagues.
Prototype for assignment is T & operator = (const T & rhs).
- The prototype can be different, but it usually shouldn't be.
The assignment return value is *this.
In this case, a returning a value reference is efficient and safe.
- Normally returning a value reference is a red flag.
T operator = (const T & rhs) is more expensive - makes a copy.

Assignment vs. Copying

What's the difference between assignment and copying?
- Assignment redefines, copying defines (or initializes).
Sometimes copying looks like assignment.
- turtle t1 = t2;
Despite the syntax, declared variables are initialized; the target state is undefined. - unintentional replication and dangling pointers.
In assignment, the target is defined and is redefined - unintentional replication, dangling pointers and garbage.
Deallocate the lhs, then replicate the rhs.
Assignment and copy constructors usually can share code - duplicate code is bad code.
Assignment vs. copy - redefinition vs. initialization; the state of the target.

The Rule of Three

If a class implements a destructor, a copy constructor, or an assignment operator, then it needs to implement all three.
Classes with pointer-type instance variables need them all.
The rule is non-symmetric, and not hard and fast.
- A destructor without a body breaks the rule.
  - A virtual destructor tends to have no body.
- Either the other two may or may not imply the other two.
  - Implemented for debugging or performance analysis.
However, any class with explicit pointers must obey the rule.

Points to Remember

Use statically allocated memory.
- But use it carefully, and well.
Dynamic memory and classes were not made for each other.
- The combination is ripe for abuse.
Learn and follow the Rule of Three.
- The troika: destructors, copy constructors, assignment.
Assignment is tricky.
- Return value, memory management, self assignment.

This page last modified on 23 March 2004.