Highlights of this lab:

In this lab,  you will:

• See the definition of a pointer.
• Observe the basic pointer operators.
• Master the mechanism for simple pointer manipulation.
• Realize how to use pointers to pass parameters by reference.
• Recognize how to use pointers with structures.
• Learn how pointers are used in conjunction with dynamic data .
• Discover what happens when a pointer goes into the unknown!

Online Videos

Lab Exercise:

Definition of a Pointer.

You won't always know the specific value in a pointer, but you won't care as long as it contains the address of the variable you are after. You need to declare and initialize pointers just as you would other variables, but there are special operators that you need to use.

Pointer Operators.

Simple Pointer Use.

First, we'll declare two ordinary integers, and also pointers to those integers.

int 	alpha 	= 5;
int 	beta 	= 20;
int*	alphaPtr	=  α
int*	betaPtr	=  β

int*	alphaPtr	=  α

An aside here: It is also permissable to position the asterisk closer to the pointer variable name,
i.e. int  *alphaPtr.   However the convention seems to be moving towards placing the asterisk closer to the datatype.

Try to visualize memory after these declarations, thinking of the pointer variable as not having a particular value, simply links to the variables to which they had been assigned.

Now let's look at a trivial example of how to access this data.
*alphaPtr += 5;
*betaPtr += 5;
After these statements, it is only the contents of the alpha and beta variables that would be changed.

You might say, "What's the big deal here? I could just as easily have written this:"
alpha += 5;
beta += 5;

Click here to download a simple pointer program.

Using Pointers to Pass Parameters by Reference.

Let's look at both pass by value and pass by reference to make sure we understand the difference. Here is a little example that illustrates how parameters are passed by value. Here's what that looks like:

	int a = 5;
	int b = 9;
	swap(a,b);    // main pgm function call
	...
	void swap(int x, int y)	// pass by value
	{
	    int temp;
	    temp = x;
	    x = y;
 	    y = temp;
	    return;
	}

To do this, you need to change the function prototype and header to
void swap(int & x, int & y)
Here is what the whole program looks like.

//Filename: swap.cpp

#include <string.h>
#include <iostream>

using namespace std;

void swap (int& x, int& y);

int main ()
{
   int a = 5;
   int b = 9;

   cout << "This program exchanges 2 values using reference parameters." << endl;
   cout << "Values before the exchange:" << endl;
   cout << "a= " << a << " b= " << b << endl;

   swap(a, b);  // code that calls the function

   cout << "Values after the exchange:" << endl;
   cout << "a= " << a << " b= " << b << endl;
}


// function for passing by reference 
void swap (int& x, int& y)
{
   int temp;

   temp = x;
   x = y;
   y = temp;
   return;
} // end swap

Now, when the function is executed, the values of a and b will be changed in the main program.

(Click to download swap.cpp)

// function for passing by reference using pointers
void swap (int* x, int* y)
{
   int temp;

   temp = *x;
   *x = *y;
   *y = temp;
   return;
} // end swap

Why do we have to put the * in front of x and y when we are doing assignment?

Note that our call from main will be:

swap (&a, &b);

It may seem like we have added a level of complexity to pass by reference, but trust me, this information will help you if you ever work with traditional C functions (found in CS330).

Next, we will look at how pointers are used with C++ structures.

Pointers and Structures

	struct Student	// define the structure
	{
	    string name;
	    int id;
	    int mark[3];
	};
	....
	void main()
	{
	    Student stu;	// declare an instance of the structure

	function_name(&stu);

	Student *    stuPtr  = &stu;

	structure_name  *    pointer_name   =  & instance_name;

	(*stuPtr).id   =  1999;

The syntax get awkward here though. i.e. (*stuPtr).id    While that form of reference is technically correct, it is somewhat cumbersome, so C++ also allows another, easier form of reference.

	stuPtr->id = 1999;

Dynamic Data and Pointers.

The new operator is used to create dynamic data variables in the so-called free store, available in memory for this purpose. Free space is also referred to as the heap. (Even gurus have been known to let their hair down sometimes.) A couple of points to remember when you use the new statement.

1. You can't directly name a dynamic data variable as you can other regular variables. If you can't name it, then how do you reference it? The answer is that you do this with a pointer.
2. When the new operation is executed, it returns a pointer to the location of the variable space in the free store.

int* tmpPtr   =  new  int;

You can declare arrays in free store as well as simple variables.
e.g. int* weightPtr = new int [3];
To use this dynamic array element you could code:

	weightPtr[1] = 17;  // Note: the "*" is not needed in an array reference.

We'll see more of this in the programming exercise for this week's lab exercise. The whole idea of using dynamic data is to economize on memory space. So when you've finished with a piece of dynamic data you should release the space with the delete statement.

delete tmpPtr;
delete [] weightPtr;

To safeguard an inadvertent overwrite of a critical area in memory, it is advisable to set pointers to NULL (or nullptr) after you delete the associated dynamic data space. e.g.

tmpPtr = NULL; //or tmpPtr = nullptr
weightPtr = NULL; //or weightPtr = nullptr

Pointers Running Wild!!

Segmentation fault - core dump.

Normal people deal with the core file more simply:

	rm   core

But what about the problem that caused the dump in the first place?! Well, if you're using pointers in your program, it's likely that one of them took on a bad value. Go back to your source code and look for statements that change pointer values. Remember that when you are in emacs, you can search for a particular string (such as the name of a pointer) by entering: C-s search_string

Lab Exercise: