Pointers and Dynamic Data

Pointers

pointer variables hold memory addresses instead of other data such as integers, floats, chars, etc.

there is no pointer keyword in C++; we use the asterisk * instead:

int* iPtr;    // a pointer to an int
float* fPtr;  // a pointer to a float

to use pointers, memory must first be allocated at the address pointed to
many errors occur because pointer variables contain addresses that the programmer did not intend them to have
a pointer must point to data of some particular type, such as an int, a float, an array of int, a structure, an class object, etc.
pointer variables must be initialized just as the other variable types do, otherwise they point to random addresses which may contain random data
using pointer variables allows us to use memory dynamically (at runtime) when we know how much we need

Dynamic Memory Allocation

allocating memory dynamically requires the programmer to do so explicitly using the new keyword

memory is allocated from the heap (also called the free store)

int* iPtr = new int;    
int* arrayPtr = new int[50];
char* name = new char[100];

the programmer must deallocate or free the memory that was allocated with new
you must verify that the allocation was successful; the new operator returns NULL if no memory available
```
if (name == NULL)    
  // allocation failed
else
  // allocation succeeded
```

the keyword delete is used to free the allocated memory

delete iPtr;    
delete [] arrayPtr;
delete [] name;

if you fail to delete the memory you allocated, you may end up with memory leaks

Allocating and Freeing Memory

use new to allocate memory dynamically
when the program ends, any dynamically allocated memory is released
use delete if you need the space earlier

a good practice is to deallocate when you no longer need the space

#include <assert.h>

void main(void)
{
  int size = 100;
  char* array = new char[size];
  assert(array);  
  
  int* iPtr = new int;
  assert(iPtr);  

    // use iPtr and array

  delete iPtr;     
  delete [] array;  
}

avoid inaccessible objects (memory leaks) and dangling pointers

Using assert

include <assert.h>
tests a condition and possibly aborts; it is asking the system to "make sure that this is TRUE"
```
assert( ptr != NULL);
```
Declaration looks like this:

void assert(int test);

assert is a macro that expands to an if statement. If the test evaluates to 0, assert prints a message to stderr like this: Assertion failed: test, file , line

#include <assert.h>

void main(void)
{
  int* iPtr = new int[500000000]; // 500,000,000

  assert(iPtr != NULL);  
}

The output would look something like this:

  Assertion failed: iPtr != NULL, file driver.cpp, line 7

Array Names are Pointers

The name of an array without the brackets is a pointer. The following code shows how to initialize an array of integers by calling the function initializeArray(...)

void main(void)
{
  int a[50];

  initializeArray(a, 50);  
}

The implementation of the function might look like this:

void initializeArray(int anArray[], int arraySize)
{
  for (int i = 0; i < arraySize; i++)
    anArray[i] = 0;
}

Or, it could be like this: (note that the function body doesn't change)

void initializeArray(int* anArray, int arraySize)
{
  for (int i = 0; i < arraySize; i++)
    anArray[i] = 0;
}

Declaring the formal parameter as int* anArray or as int anArray[] is the same to the compiler. Within the function, anArray points to the beginning of the actual array.

Modified Employee Class and Function

Recall our implementation of the setName function of the Employee class:

void Employee::setName(char first[], char last[])
{
  if (strlen(first) > 9)     // if too long, truncate
  {
    strncpy(firstName, first, 9);
    firstName[9] = '\0';
  }
  else
    strcpy(firstName, first);

  if (strlen(last) > 11)     // if too long, truncate
  {
    strncpy(lastName, last, 11);
    lastName[11] = '\0';
  }
  else
    strcpy(lastName, last);
}

We can modify the private data members to be pointers:

private:
    char* firstName;   // was char firstName[]
    char* lastName;    // was char lastName[]

and then implement the function this way:

void Employee::setName(char first[], char last[])
{
  firstName = new char[strlen(first) + 1];
  strcpy(firstName, first);

  lastName = new char[strlen(last) + 1];
  strcpy(lastName, last);
}

Modified Employee Class and Function (cont)

A more robust way would be like this:

void Employee::setName(char first[], char last[])
{

    // if firstName already allocated, free it
  if (firstName != NULL)
    delete [] firstName;

    // allocate room for the first name
  firstName = new char[strlen(first) + 1];

    // make sure the allocation succeeded
  assert( firstName != NULL);

    // copy the contents of the parameter to firstName
  strcpy(firstName, first);

    // if lastName already allocated, free it
  if (lastName != NULL)
    delete [] lastName;

    // allocate room for the last name
  lastName = new char[strlen(last) + 1];

    // make sure the allocation succeeded
  assert(lastName != NULL);

    // copy contents of the parameter to lastName
  strcpy(lastName, last);
}

Using Reference Types

reference types contain addresses like pointers, but there are two differences
reference variables do not need the address-of operator (&) or the de-referencing operator (*)
the compiler automatically de-references a reference variable

reference variables must be initialized to refer to another variable when they are declared:

int a;           
int& iRef1 = a;   // correct

int& iRef2;       // incorrect        
iref = a;    

int& iRef3 = 5;   // incorrect

a reference variable is also called an alias
all operations on the alias apply to the referenced variable and vice-versa

int a = 25;      // a is 25
int& iRef = a;   // iRef is 25, a is 25
a = 15;          // a is 15, iRef is 15
iRef = 10;       // iRef is 10, a is 10

Reference Parameters in Functions

This function doesn't work correctly:

void SwapInt(int a, int b)
{
  int temp;

  temp = a;
  a = b;
  b = temp;
}

This function works correctly using pointers:

void SwapInt(int* a, int* b)
{
  int temp;

  temp = *a;
  *a = *b;
  *b = temp;
}

This function works correctly using reference parameters:

void SwapInt(int& a, int& b)
{
  int temp;

  temp = a;
  a = b;
  b = temp;
}

Using the & Operator (page 990)

Position       Usage                      Meaning
Prefix         &Variable                 Address-of operation
Infix          Expression & Expression   Bitwise AND operation
Infix          Expression && Expression  Logical AND operation
Postfix        DataType&                 Reference variable initialization

int a;
int* iPtr = &a;     // address-of operation
int& iRef = a;      // reference variable

if ( (a > 10) && ( a < 20) )   // logical AND
  doSomething();

Back to Outline