Syntax for bonus lab

Key syntax elements for bonus lab

For the bonus lab we'll be introducing pointers, pointers as parameters, pointers to structs, and dynamic memory allocation and deallocation using new and delete.

Basic pointer use

In lectures we went over the basics of creating and using pointers, but the following program illustrates them briefly.

The resulting output is shown afterwards (the 'Segmentation fault' actually comes as a result of a runtime crash).

#include <iostream>
using namespace std;

int main()
{
   int x;
   x = 5;
   cout << "x is initially " << x << endl << endl;

   int* myptr; // variable myptr can be used to store the memory address of any int variable
   myptr = &x; // here the &x looks up the memory address of variable x,
               // which we then store in myptr

   cout << "after storing the address of x into myptr," << endl;
   cout << "   the memory address stored in myptr is " << myptr << endl;
   cout << "and the value we find in that memory location is " << (*myptr) << endl << endl;

   *myptr = 10; // *myptr refers to whatever is stored at the given address,
                //  i.e. (*myptr) is now a way of indirectly getting at x's contents
   cout << "after putting value 10 into memory at that location," << endl;
   cout << "   x is now " << x << endl << endl;

   myptr = nullptr; // nullptr is a special value, an alias for memory address 0,
                    // which is generally used to indicate that a pointer variable
                    // currently is NOT actually 'pointing at' anything

   cout << "After assigning null as a memory address," << endl;
   cout << "   myptr is now " << myptr << endl << endl;

   cout << "and the value stored at that location is: ";
   cout << (*myptr) << endl << endl;
   //  here ^^^^^^ the program crashes (segmentation fault) because we tried to
   //  look at the memory contents at address 0, which isn't a valid address
}


x is initially 5

after storing the address of x into myptr,
   the memory address stored in myptr is 0x7ffce2a55954
and the value we find in that memory location is 5

after putting value 10 into memory at that location,
   x is now 10

After assigning null as a memory address,
   myptr is now 0

Segmentation fault

Pointers as parameters

In C (the ancestor of C++) there was no concept of pass-by-reference, so the same effect was achieved by having the caller pass a pointer to (i.e. the address of) a variable, then the called function could get at and manipulate the contents of the original variable.

A simple pointer-based version of a swap function is shown below

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

int main
{
   int a = 10;
   int b = 123;
   swap(&a, &b); // pass the addresses of the two variables
   // a is now 123, b is now 10
}

// swap the contents of the variables x and y point to
void swap(int* xptr, int* yptr)
{
   int oldX = *xptr;
   *xptr = *yptr;
   *yptr = oldX;
}

Pointers to structs

We saw that with regular struct variables we could access the fields of the struct using variablename.fieldname, e.g.

struct StudentInfo {
   string name;
   float GPA;
};

int main()
{
    StudentInfo s1;
    s1.name = "Somebody";
    s1.GPA = 3.66;
}

But if we had a pointer to the struct then we'd need to use (*variablename).fieldname, e.g.

int main()
{
    StudentInfo s1;
    StudentInfo* sptr;
    s1.name = "Somebody";
    s1.GPA = 3.66;
    sptr = &s1; // so the pointer 'points at' s1
    // if we want to go through the pointer to change s1's data fields ...
    (*sptr).name = "Nobody";
    (*sptr).GPA = 0.00;

}

This notation can get awkward when there are structs inside structs inside structs, so an alternative notation (that accomplishes the same thing) is variablename->fieldname, e.g.
sptr->name = "Nobody"; sptr->GPA = 0.00;
Dynamic memory handling: new and delete
To make more efficient/effective use of memory, a program will sometimes wait until the last moment to request memory storage for something, then 'release' that memory as soon as possible afterwards.
This often happens when the item is large (e.g. a really big array) or when working with a data structure that grows and shrinks over time (e.g. a linked list, where we're creating and adding or removing and deleting one element of the list at a time).
The operator to request storage is called 'new', while the operator to release it is called 'delete'.
We'll focus on the creation and deletion of arrays and structs here.

For arrays, the allocation and deallocation works as follows:

To allocate an array of floats we need a float* variable that will keep track of where the system creates the array for us, and we'll need to know how big an array we want, then we call 'new' to get the array created and return its address:

int size;
float *myNumbers;
cout << "Enter the desired array size: ";
cin >> size; // should add error checking of course
myNumbers = new float[size];  // creates an array of floats, using the specified size

The array can be used normally from this point on, e.g. myNumbers[7] would refer to the element in position 7.

To deallocate the array (once we're completely finished with it) we use delete (with [] to specify we're deleting an entire array):

delete [] myNumbers;  // deallocates the memory for the array

For allocating single structs, the process is similar but without the [size] or []"

// using the same MyInfo struct as in the earlier syntax example
MyInfo *infoPtr;
infoPtr = new MyInfo;  // new allocates an instance of the struct and return its address
infoPtr->name = "me";  // note we're accessing the fields using -> since infoPtr is a pointer to a struct
infoPtr->GPA = 2.5;
...
// eventually we're done using that item and want to delete it
delete infoPtr;