Pointers and Pointer

based strings
Pointers

▪ Pointers are special variables in C++ that store the memory address of a
variable.
▪ A pointer can "point" to any variable or data type and can be used to
access the contents of the variable.
▪ Pointers are different from references because a reference variable is
an alias for an existing variable. A pointer can point to any memory
location and can be changed.
▪ Pointers are used to store the address of another variable, but
references are not capable of that. Pointers are also used for dynamic
memory allocation, which means that memory can be allocated as and
when it's needed, making them very useful.
2
Address in C++

▪ If we have a variable var in our program, &var will give us its address

in the memory. For example,

3
Pointer Declaration and Initialization

▪ Pointer declaration is the process of declaring a pointer, which is

done by stating the data type followed by an asterisk (“*”) and the
pointer's name.
▪ Pointer initialization is the process of assigning a memory address to
a pointer, which is done using the "&" operator.
▪ Example:

4
Dereferencing pointers

▪ In the example from the previous page, we used the pointer variable to get the
memory address of a variable (used together with the & reference operator).
However, you can also use the pointer to get the value of the variable, by using
the * operator (the dereference operator):

▪ Note that the * sign can be confusing here, as it does two different things in our
code:
– When used in declaration (string* ptr), it creates a pointer variable.
– When not used in declaration, it act as a dereference operator.
5
C++ Modify Pointers

▪ You can also change the pointer's

value. But note that this will also
change the value of the original
variable:
▪ Example:-

6
Example Working
with pointers

7
Example
Modifying Pointer
values

8
Activity One

▪ Write a program to print the address of a variable whose value is

input from user.
▪ Write a program to print the address of the pointer to a variable
whose value is input from user.
▪ Write a program to print a number which is entered from keyboard
using pointer.

9
C++ Pointers and Arrays

▪ In C++, Pointers are variables that hold addresses of other variables.

Not only can a pointer store the address of a single variable, it can
also store the address of cells of an array.
▪ Consider this example:

▪ Here, ptr is a pointer variable while arr is an int array. The code ptr =
arr; stores the address of the first element of the array in variable ptr.

10
▪ Notice that we have used arr instead of &arr[0]. This is because both
are the same. So, the code below is the same as the code in the
previous slide.

▪ The addresses for the rest of the array elements are given by &arr[1],
&arr[2], &arr[3], and &arr[4].

11
Point to Every Array Elements

▪ Suppose we need to point to the fourth element of the array using

the same pointer ptr.
▪ Here, if ptr points to the first element in the above example then ptr
+ 3 will point to the fourth element. For example,

12
Note:

▪ The address between ptr and ptr + 1 differs by 4 bytes. It is because

ptr is a pointer to an int data. And, the size of int is 4 bytes in a 64-bit
operating system.
▪ Similarly, if pointer ptr is pointing to char type data, then the address
between ptr and ptr + 1 is 1 byte. It is because the size of a character
is 1 byte.

13
Example:

In simple words, array

names are converted to
pointers. That's the
reason why we can use
pointers to access
elements of arrays.

However, we should
remember that pointers
and arrays are not the
same.
to pointers. 

14
Example 2:

Array name
used as pointer

15
Example 2:
Explained

16
Activities

▪ Write a C++ program to find the sum of Array elements using a

pointer.
▪ Write a C++program to find the length of a String using a pointer.

17
Pointers and Functions

▪ In chapter two, we learned about passing arguments to a function.

This method used is called passing by value because the actual value
is passed.
▪ However, we also saw another way of passing arguments to a
function where the actual values of arguments are not passed.
Instead, the reference to values is passed.

18
Example Explained

▪ So, when we call the func2() function in main() by passing the

variable num as an argument, we are actually passing the address of
num variable instead of the value 5.

19
Example 1

Passing By
Reference
without
Pointers.

20
Example 1 explained

▪ In this program, we passed the variables a and b to the swap() function. Notice
the function definition,

▪ Here, we are using & to denote that the function will accept addresses as its
parameters.
▪ Hence, the compiler can identify that instead of actual values, the reference of
the variables is passed to function parameters.
▪ In the swap() function, the function parameters n1 and n2 are pointing to the
same value as the variables a and b respectively. Hence the swapping takes
place on actual value.
▪ The same task can be done using the pointers.

21
Example 2: Passing by reference using
pointers

22
Example 2 Explained.

▪ Here, the address of the variable is passed during the function call
rather than the variable.
▪ Since the address is passed instead of value, a dereference operator
* must be used to access the value stored in that address.
*n1 and *n2 gives the value stored at address n1 and n2
respectively.

Since n1 and n2 contain the addresses of a and b,

anything is done to *n1 and *n2 will change the actual
values of a and b.

Hence, when we print the values of a and b in the main()

function, the values are changed.
23
Memory Management in C++

▪ C++ allows us to allocate the memory of a variable or an array in run

time. This is known as dynamic memory allocation.
▪ In other programming languages such as Java and Python, the
compiler automatically manages the memories allocated to
variables. But this is not the case in C++.
▪ In C++, we need to deallocate the dynamically allocated memory
manually after we have no use for the variable.
▪ We can allocate and then deallocate memory dynamically using the
new and delete operators respectively.

24
C++ new Operator

▪ The new operator allocates memory to a variable. For example,

▪ Here, we have dynamically allocated memory for an int variable using the new
operator.
▪ Notice that we have used the pointer pointVar to allocate the memory
dynamically. This is because the new operator returns the address of the
memory location.

25
Syntax

▪ In the case of an array, the new operator returns the address of the
first element of the array.\
▪ From the example above, we can see that the syntax for using the
new operator is

26
delete Operator

▪ Once we no longer need to use a variable that we have declared

dynamically, we can deallocate the memory occupied by the variable.
▪ For this, the delete operator is used. It returns the memory to the
operating system. This is known as memory deallocation.
▪ The syntax for this operator is:

27
▪ Consider the code:

▪ Here, we have dynamically allocated memory for an int variable using the pointer
pointVar.
▪ After printing the contents of pointVar, we deallocated the memory using delete.

28
Note:

▪ If the program uses a large amount of unwanted

memory using new, the system may crash because
there will be no memory available for the operating
system. In this case, the delete operator can help
the system from crash.

29
Example 1: C++
Dynamic Memory
Allocation

▪ In this program, we
dynamically allocated
memory to two variables of
int and float types. After
assigning values to them
and printing them, we
finally deallocate the
memories using the code:

30
Note:

▪ Dynamic memory allocation can make memory

management more efficient.
▪ Especially for arrays, where a lot of the times we don't
know the size of the array until the run time.

31
Example 2: C++ new and
delete Operator for
Arrays

32
Example 2 explained.

▪ In this program, we have asked the user to enter the number of

students and store it in the num variable.
▪ Then, we have allocated the memory dynamically for the float array
using new.
▪ We enter data into the array (and later print them) using pointer
notation.
▪ After we no longer need the array, we deallocate the array memory
using the code delete[] ptr;.
▪ Notice the use of [] after delete. We use the square brackets [] in order
to denote that the memory deallocation is that of an array.
33