Pointers and References in C++

Dr Ian Cornelius

Hello

Hello (1)

Learning Outcomes

Understand the concept of pointers and references and their purpose in C++
Understand how to manage memory in C++

Pointers

Pointers (1)

Pointers hold the address for a declared variable
The asterisk (*) after int means pointer to
Pointers are intended to map directly to addressing mechanisms of the machine
There are three ways of declaring a pointer variable:
1. int * pIntExample1
2. int *pIntExample1
3. int* pIntExample1 - preferred method

int intExample1 = 32;
int* pIntExample1 = &intExample1;

#include <iostream>
int intExample1 = 32;
int* pIntExample1 = &intExample1;
int main() {
  std::cout << "intExample1 -> " << intExample1 << std::endl;
  std::cout << "&pIntExample1 -> " << &pIntExample1 << std::endl;
  return 0;
}

intExample1 -> 32
&pIntExample1 -> 0x5556c43fe018

The first topic of this lecture we shall be looking at is pointers, and the role they play in C++ and why they are important. A pointer is used to hold the address for the value of a declared variable. Pointer variables are used to point to a data type of the same type and are created with the asterisk operator. The address of the variable that is assigned to the pointer variable will be the memory address.

On the screen, you will see an example. In this example we have assigned the value 32 to our variable called intExample1. To create a pointer to this variable, we need to create a new variable of the same data type, in this case an int and provide an asterisk at the end of the data type. You will see that when I have named this pointer variable, I have prefixed it with the letter p followed by the name of the variable I am creating the pointer for.

If you are going to be using pointers in your work, this would be a good habit to get yourself into, as it will clearly differentiate between which variable is the pointer and which one is not when it comes to using any form of code completion in your IDE.

Once I have declared my pointer variable, I can now assign the variable I wish to get the memory address of. In this case, I provide the variable intExample1. However, you will notice that I have prefixed the variable name with an ampersand. The ampersand operator is used to store the memory address of the variable and assign it to the pointer. At this point, or variable pIntExample1 now stores the memory address of intExample1 and you can see this from the output on the screen.

When it comes to creating our pointer variables, there are three methods of doing it. The first method would be providing the asterisk not attached to the data type of the variable name, the second method is where the asterisk is attached to the variable name, and the third (and preferred method) is where the asterisk is attached to the data type. As I have mentioned before, it is also a good to get into the habit of prefixing your pointer variables with the letter p to easily distinguish which variable is the pointer and is not.

Pointers (3)

Variables and Memory i

Variables are stored in the memory and visualised as a series of unique addressed boxes
The operating system will pick an unused memory location, e.g. 0x1234
- there must be enough space available to store the variable
  - e.g. four bytes for an int
intExample1 is the name of the reserved memory location

int intExample1 = 32;
int* pIntExample1 = &intExample1;

#include <iostream>
int intExample1 = 32;
int* pIntExample1 = &intExample1;
int main() {
  std::cout << "intExample1 -> " << intExample1 << std::endl;
  std::cout << "&pIntExample1 -> " << &pIntExample1 << std::endl;
  return 0;
}

intExample1 -> 32
&pIntExample1 -> 0x5577552b5018

When it comes to storing our variables in the memory, they are visualised as a series of unique address boxes. In this case the operating system will pick an unused memory location, i.e. 0x124 and then store the contents of our variable in it. The compiler will pick a memory address that has sufficient space in order to store the value of the variable.

In our previous example, we were using the variable intExample1 which was an integer data type storing the value 32. You should recall from a previous lecture that an integer occupies four bytes of memory. Therefore, our compiler needs to reserve four bytes of memory in order to store our value, 32.

On the right-hand-side of the screen, you will see an example of what a typical memory address would look like. In this example, the variable intExample1 is the name of our reserved memory location, and the variable pIntExample1 is a pointer to the memory address.

Pointers (4)

Variables and Memory ii

Array elements are stored sequentially in a contiguous block of memory
- larger objects may span multiple blocks, i.e. arrays, classes, and floats

#include <iostream>
int arrayExample1[4] = {5, 0, 6, 2};
int main() {
  for(int &element : arrayExample1) {
    std::cout << "element -> " << element << " [Address: " << &element << "]" << std::endl;
  }
  return 0;
}

element -> 5 [Address: 0x55e34c89f010]
element -> 0 [Address: 0x55e34c89f014]
element -> 6 [Address: 0x55e34c89f018]
element -> 2 [Address: 0x55e34c89f01c]

When it comes to storing array elements in the memory, they are stored sequentially in a contiguous block of memory. The term contiguous in this case refers to the consecutive blocks of memory that are allocated for storing our array.

On the right-hand-side of the screen, you will see an example of an array. In this example, I have created an array that reserves four blocks of memory and stores the values 5, 0, 6 and 2. Just below it, I have used a control statement to extract each element from the array and print its value and memory address to the screen.

We can see from the memory address output that our memory address increments by four bytes each time, and this is because we are storing an integer in our array. For example, our first element, five, is stored at a memory address ending in 010, whereas our next element six, is stored at a memory address ending in 014. But why does it jump from 018 to 01c? Well, memory addresses in C++ are printed in a hexadecimal (base 16) form. This means that the address scheme uses numeric digits zero to nine, along with the letters a to f, and these letters represent the numeric values of 10 to 15..

Pointers (5)

Null Pointers

Pointers can also point to a null object
- can be achieved with the nullptr keyword
nullptr can be assigned to any pointer type, but not to built-in data types
There is only one nullptr and can be used for every pointer type

int* pIntExample1 = nullptr;
double* pDoubleExample1 = nullptr;
int intExample1 = nullptr; // Throws an error as intExmaple1 is not a pointer

Pointers (6)

Pointers into Arrays i

Pointers and arrays are closely related in C++
The name of an array can be used as a pointer to its initial element
- requesting an element address before the initial or beyond size of an array should be avoided

Create an array, arrayExample1 containing four values
- pointer1 is a pointer to the initial element
- pointer2 is a pointer to the initial element (in a different syntax)
- pointer3 is a pointer to a different element in the array
- pointer4 is a pointer to a memory address beyond the last element

int arrayExample1[4] = {5, 0, 6, 2};
int* pointer1 = arrayExample1;
int* pointer2 = &arrayExample1[0];

#include <iostream>
int arrayExample1[4] = {5, 0, 6, 2};
int main() {
  int* pointer1 = arrayExample1;
  std::cout << "pointer1 -> " << pointer1 << std::endl;
  int* pointer2 = &arrayExample1[0];
  std::cout << "pointer2 -> " << pointer2 << std::endl;
  return 0;
}

pointer1 -> 0x55fce58ad010
pointer2 -> 0x55fce58ad010

int arrayExample1[4] = {5, 0, 6, 2};
int* pointer3 = arrayExample1+2;
int* pointer4 = arrayExample1+6;

#include <iostream>
int arrayExample1[4] = {5, 0, 6, 2};
int main() {
  int* pointer3 = arrayExample1+2;
  std::cout << "pointer3 -> " << pointer3 << std::endl;
  int* pointer4 = arrayExample1+6;
  std::cout << "pointer4 -> " << pointer4 << std::endl;
  return 0;
}

pointer3 -> 0x560882c44018
pointer4 -> 0x560882c44028

Pointers and arrays are closely related in C++, and the name of an array can be used as a pointer to its initial element. Let’s have a look at an example of how this will work. On the screen, we have an array called arrayExample1, which stores the values 5, 0, 6 and 2.

The first two pointers are an example of how referring to the variable name holding an array can get the same memory address as it would be for a pointer to the first element of the array.

The third pointer is an example of how we can get an element memory address by using the plus operator followed by the number of indexes to skip. Therefore, in this instance, we are pointing to index two, which holds the element number six. However, the fourth pointer example is where we are pointing to a memory address that is beyond the last element. Pointers to an element beyond the last element of an array are guaranteed to work and can be important for many algorithms. However, because this pointer does not in fact point to an element that is inside the array, then it cannot be used for reading or writing.

Pointers (7)

Pointers into Arrays ii

Arrays can be iterated through using a pointer
Often chosen by developers based on aesthetic or logical reasoning
There is no performance gain over the usual method

Iterating using a Pointer

#include <iostream>
char arrayExample1[] = {'5', '0', '6', '2'};
int main() {
  for(char* pointer = arrayExample1; *pointer != 0; pointer++) {
      std::cout << "*pointer -> " << *pointer << std::endl;
  }
  return 0;
}

*pointer -> 5
*pointer -> 0
*pointer -> 6
*pointer -> 2

Iterating Normally

#include <iostream>
char arrayExample1[] = {'5', '0', '6', '2'};
int main() {
  for(char &element : arrayExample1) {
      std::cout << "element -> " << element << std::endl;
  }
  return 0;
}

element -> 5
element -> 0
element -> 6
element -> 2

Sometimes when you are reading code from the internet, you may come across some developers who iterate through an array using a pointer. Whilst there is no performance gain over the original method of iteration (as discussed in week nine), developers often choose their method on logical and aesthetic reasoning.

On the left-hand-side of the screen, you will see an example of how we can iterate through our array of characters by using a pointer. The first thing you will notice is that we have used a char* pointer as our initialiser for the loop. We then perform a check to ensure that our pointer does not equal to zero, and increment it by one using p++. Inside the body of the for loop, I print the value of the pointer to the screen. In this case, you can see that when the code is executed the values 5, 0, 6 and 2 are printed to the screen.

On the right-hand-side of the screen, you will see the normal method of how I would normally iterate through an array. As you can see, it occupies the same number of lines—but personally, the second example is a little more pleasing to the eye and readable. However, this is a personal preference, and each programming will have their own opinions on which method is better.

References

References (1)

Reference variables are an alias, another name for a variable that exists
Once initialised, either the variable name or reference name can be used to refer to the variable
References are often confused with pointers, but have three differences:
- you cannot have a null reference
- once initialised to an object, it cannot be changed to refer to another object
- references must be initialised when created
References are often used for:
- function argument lists
- function return values

The next topic we shall be exploring is references. A reference is an alias (or another name) for a variable that already exists. Once the reference has been initialised, either the variable name or the newly created reference name can be used to refer to that variable.

References are often confused with pointers, but they in fact have a few differences. For example, you cannot have a null reference with a reference, and once it has been initialised to an object, it cannot be changed or switched to an alternative object; this is because references must be initialised when they are created.

References are often used for function argument lists, or function return values. But what exactly do we mean by this? Well, over the next few slides, we shall look at a variety of examples to gain a better understanding of how references work.

References (2)

Creating a Reference

References are initialised using the ampersand (&) character
The first int declaration is a new object being created
The second int declaration (with the &) is the reference object
- this will refer to the memory address of intExample1

#include <iostream>
int main() {
  int intExample1 = 32;
  int& rIntExample1 = intExample1;
  std::cout << "intExample1 -> " << intExample1 << "  [Address: " << &intExample1 << "]" << std::endl;
  std::cout << "rIntExample1 -> " << rIntExample1 << " [Address: " << &rIntExample1 << "]" << std::endl;
  return 0;
}

intExample1 -> 32  [Address: 0x7ffc9877cf8c]
rIntExample1 -> 32 [Address: 0x7ffc9877cf8c]

When it comes to creating a reference in C++, I often prefix my reference variable names with the letter r, similar to how I prefix my pointers with the letter p. This clearly denotes to me in my code, which is my reference variable and which is not.

References are initialised using the ampersand character, as you can see in the example on the right-hand-side of the screen. The first int declaration is where a new object is being created, whilst the second int declaration (with the ampersand) is the creation of our reference object. This reference object will refer to the same memory address of intExample1 and as such would also store the same value of 32 as you can see from the output on the screen.

References (3)

Pass by Reference

The swap() function consists of two parameters
- each refers to the address location

#include <iostream>
void swap(int &x, int &y) {
  int tmpX;
  tmpX = x;
  x = y;
  y = tmpX;
}
int main() {
  int intExample1 = 5;
  int intExample2 = 10;
  std::cout << "[Before] intExample1 -> " << intExample1 << "  [Address: " << &intExample1 << "]" << std::endl;
  std::cout << "[Before] intExample2 -> " << intExample2 << " [Address: " << &intExample2 << "]" << std::endl << std::endl;
  swap(intExample1, intExample2);
  std::cout << "[After]  intExample1 -> " << intExample1 << " [Address: " << &intExample1 << "]" << std::endl;
  std::cout << "[After]  intExample2 -> " << intExample2 << "  [Address: " << &intExample2 << "]" << std::endl;
  return 0;
}

[Before] intExample1 -> 5  [Address: 0x7ffd36ff8250]
[Before] intExample2 -> 10 [Address: 0x7ffd36ff8254]

[After]  intExample1 -> 10 [Address: 0x7ffd36ff8250]
[After]  intExample2 -> 5  [Address: 0x7ffd36ff8254]

In your first year programming module, you would have been introduced to a concept known as pass-by-reference. To recap, pass-by-reference means to pass a reference as an argument in our function call to the corresponding parameter in our function header.

When the function is called, it can then modify the value of the argument by using the reference that has been passed. To pass-by-reference in C++, we need to include the ampersand operator in our function header on the parameter variable names. On the screen is an example of swapping two integer numbers. You will see that in the function header we have two parameters that have an ampersand attached to the variable name. This tells the compiler that we are passing our values through by reference.

When we call the function swap, the values of our variables intExample1 and intExample2 are switched because they have been passed through as a reference. Using pass-by-reference in C++ is more efficient compared to its counter-part, pass-by-value as it does not copy the arguments across.

References (4)

Return as Reference from a Function

C++ functions can return a reference, similar to how they can return pointers
When returning a reference, it returns an implicit pointer to the return value
- take care not to return a reference outside the scope of an array

#include <iostream>
int arrayExample1[4] = {5, 0, 6, 2};
int arrayLength = sizeof(arrayExample1) / sizeof(int);
int& set_value(int i) {
  return arrayExample1[i];
}
int main() {
  for(int i = 0; i < arrayLength; i++) {
    std::cout << "[Before] arrayExample1[" << i << "] -> " << arrayExample1[i] << std::endl;
  }
  set_value(1) = -9;
  for(int i = 0; i < arrayLength; i++) {
    if(i == 0) {
      std::cout << std::endl << "[After] arrayExample1[" << i << "] -> " << arrayExample1[i] << std::endl;    
    } else {
      std::cout << "[After] arrayExample1[" << i << "] -> " << arrayExample1[i] << std::endl;
    }
  }
  return 0;
}

[Before] arrayExample1[0] -> 5
[Before] arrayExample1[1] -> 0
[Before] arrayExample1[2] -> 6
[Before] arrayExample1[3] -> 2

[After] arrayExample1[0] -> 5
[After] arrayExample1[1] -> -9
[After] arrayExample1[2] -> 6
[After] arrayExample1[3] -> 2

The C++ compiler also has a feature that enables function to return a reference to an object, similar to how they can also return pointers. When the compiler returns a reference, it is actually returning an implicit pointer to the returned value.

When you are returning by reference, you will want to be careful that the object being returned does not go outside the scope. For example, in the case of the example on the screen, we want to ensure that we do not return an object that is outside the length of the array.

Let’s have a look at our example on the screen. Here, you can see that I have our integer array example from earlier, the one storing the values: 5, 0, 6 and 2. In this example, I am concerned with changing the value of one element in the array, and returning it as a reference. You can see that I have a function called set_value which will do just that.

The function accepts a parameter, i, which returns the value at a given location for that index. You will see in the main function that after I have printed the array values (before it’s been adjusted), that I am attempting to change the value of index 1 by calling the function set_value with the argument 1. This will return the value at that given index, but as a reference. Meaning that when I attempt to re-assign our new value -9, it will overwrite the change in our array.

This can be seen in the second for loop, when I iterate through our loop again and print the values to the screen. In this case, you can see that when we get to index 1, the value has been changed from zero to minus nine.

Memory Management

Memory Management (1)

C++ has the feature of allocating the memory of variable at run time
- this is known as dynamic memory allocation
Python automatically manages the memories that are allocated to variables
- whereas C++ does not
Therefore, you will be required to deallocate the dynamically allocated memory manually
- dynamically allocated memory is deallocated manually when the variable has no further use
Allocation and deallocation of memory can be achieved using new and delete keywords, respectively
Memory in C++ is divided into two parts:
1. stack
2. heap

The last topic I want to discuss in this lecture is memory management, and why it is important that you do this in any code that you write in C++.

When it comes to running your script or application, C++ has the habit of allocating the memory for a variable at run time, and this is often referred to as dynamic memory allocation. Whilst Python automatically manages our memories for us and allocates memory ot variable when necessary, C++ does not. Therefore, you will need to deallocate any memory that has been dynamically allocated manually. This is often the case when the variable is no longer required for use. The allocation and deallocation of memory can be achieved using the new and delete keywords, respectively.

Memory management is important in C++ as it ensures that there is no wastage of memory and that the allocation can take place efficiently. The memory that is required by a C++ script is divided into different parts, otherwise known as a stack and a heap. In the stack, all the variables declared inside the function and other information related to that function is stored. However, a heap is unused memory, and the part from where memory can be dynamically allocated when the script is run.

When it comes to declaring an array, there are more often than not, times when the correct memory is not determined until runtime. Therefore, in order to avoid these scenarios, we usually declare an array of the maximum size. However, there may be cases whereby because of this full size, some memory becomes unused. An example of this would be declaring an array with the size of twenty, but when we come to use it, we only assign ten elements. Therefore, the rest of the space is of no use as it is wasted and reserved for the array.

To avoid cases like this, we use memory allocation and we can allocate the memory at runtime from the heap using keywords new and delete.

Memory Management (2)

Allocation of Memory

Memory allocation is achieved using the new keyword

int* pIntExample1 = new int;
*pIntExample1 = 32;

#include <iostream>
int main() {
  int* pIntExample1 = new int;
  *pIntExample1 = 32;
  std::cout << "pIntExample1 -> " << *pIntExample1 << " [Address: " << pIntExample1 << "]" << std::endl;
  return 0;
}

pIntExample1 -> 32 [Address: 0x55be05d432b0]

Memory has been dynamically allocated for int using the new keyword
Pointers have been used to aid in memory allocation
- the new keyword returns the address of the memory location
- in case of an array the new keyword returns the address of the first element

Memory Management (3)

Deallocation of Memory

Deallocating the memory is achieved using the delete keyword

#include <iostream>
int main() {
  int* pIntExample1 = new int;
  *pIntExample1 = 32;
  std::cout << "pIntExample1 -> " << *pIntExample1 << " [Address: " << pIntExample1 << "]" << std::endl;
  delete pIntExample1; // Deletes the variable and reserved memory
  return 0;
}

pIntExample1 -> 32 [Address: 0x562ec2cc92b0]

Once our memory has been allocated, we can also delete the memory when it is no longer required. In order to achieve this we can use the delete keyword to deallocate from the memory. Therefore, when we no longer require to use the memory we need to release the memory back to the system. TO do this, we use the delete keyword as you can see from the example on the screen.

The on-screen example is the same as the previous slide, whereby we are creating an integer using the new keyword and allocating the value 32 to be stored inside it. Once I have finished printing the details to the screen, I wish to delete the integer and release the memory. To do this, I call the delete keyword followed by the name of the variable I wish to delete, in this case pIntExample1.

Goodbye

Goodbye (1)

Questions and Support

Questions? Post them on the Community Page on Aula
Additional Support? Visit the Module Support Page
Contact Details:
- Dr Ian Cornelius, ab6459@coventry.ac.uk