Pointers are used to access array elements, pass arguments to functions by reference so the function can modify the original argument, pass arrays and strings to functions, obtain memory from the system, and create data structures like linked lists. Pointers store the address of another variable in memory. This allows the pointer variable to indirectly access the contents of the other variable through dereferencing the pointer. Functions can accept arguments passed by reference using pointers, allowing the function to modify the original argument.

1. Chapter: 10
Pointers
Lecture: 37
Date: 16.10.2012

2. What are Pointers Used For?
 Accessing array elements
 Passing arguments to a function when the function needs
to modify the original argument
 Passing arrays and strings to functions
 Obtaining memory from the system
 Creating data structures such as linked lists

3. Memory and Addresses
1270
1271
1272
1273
1274
1275
Computer Memory

4. Memory and Addresses
Addresses Locations
1270
1271
1272
1273
1274
1275
Computer Memory

5. Memory and Addresses
int IntVar1; //2 bytes
int IntVar2; //2 byte

6. Memory and Addresses
Addresses Locations
1270
1271
int IntVar1; //2 bytes
1272 IntVar1
int IntVar2; //2 byte 1273
1274
1275 IntVar2
Computer Memory

7. Memory and Addresses
int IntVar1 = 25;
int IntVar2 = 11;

8. Memory and Addresses
Addresses Locations
1270
1271
int IntVar1 = 25; 25 IntVar1
1272
int IntVar2 = 11; 1273
1274
11 IntVar2
1275
Contents/Data

10. Memory and Addresses
 In some cases we may be interested in knowing the address
where our variable is being stored during runtime.
 The address that locates a variable within memory is what
we call a reference to that variable.
e.g.,
& IntVar;
Address-of/reference
 When preceding the name of the variable “IntVar” with the
operator
reference operator (&) we are no longer talking about the
content of the variable itself, but about its reference (i.e., its
address in memory).

11. Memory and Addresses
#include <iostream>
#include <conio.h>
using namespace std;
int main()
{
int IntVar1;
int IntVar2;
cout << &IntVar1 << endl //print the addresses
<< &IntVar2 << endl;
getch();
return 0; }

12. Pointer Variable
 The variable that stores the reference to another variable is
what we call a pointer.
e.g.,
ptr = &InVar;

13. Pointer Variable
 The variable that stores the reference to another variable is
what we call a pointer.
e.g.,
Pointer-to Pointer/Pointer-variable
int * ptr; //variable “ptr” as a pointer-to “int”
ptr = &InVar;

14. Accessing Addresses
int main()
{ int IntVar1 = 25;
int IntVar2 = 11;
int* ptr; //pointer to integers
ptr = &IntVar1; //pointer points to IntVar1
cout << ptr << endl //print the address of IntVar1
ptr = &IntVar2
cout << ptr << endl //print the address of IntVar2
getch();
return 0; }

15. int* ptr; 1270
ptr = &IntVar1; ptr
1271
cout << ptr ;
1271
25 IntVar1
1272
ptr points-to to the
1273
address of IntVar1
1274
11
1275 IntVar2
1270
1271
25
1272 IntVar1
int* ptr; ptr 1273
ptr = &IntVar2;
1274 1274
cout << ptr ;
11
ptr points-to to the 1275 IntVar2
address of IntVar2

16. Accessing Contens
int main()
{ int IntVar1 = 25;
int IntVar2 = 11;
int* ptr; //pointer to integers
ptr = &IntVar1; //pointer points to IntVar1
cout << *ptr << endl //print the content of IntVar1
ptr = &IntVar2
cout << *ptr << endl //print the content of IntVar2
getch();
return 0; }

17. ptr
int* ptr;
ptr = &IntVar1; 25 IntVar1
*ptr is 25
cout << *ptr ;
11
deference /indirection operator.
IntVar2
Expression *ptr means the value of
the variable pointed to by ptr.
25
IntVar1
ptr
int* ptr;
ptr = &IntVar2; 11
*ptr is 11
IntVar2
cout << *ptr ;

18. Pointer to Void
 The address that is put in a pointer variable must be the
same type as the pointer, for example, the address of a float
variable can’t be assigned to a pointer to int.
float floVar = 25.67;
int* ptrInt = &floVar;

19. Pointer to Void
 The address that is put in a pointer variable must be the
same type as the pointer, for example, the address of a float
variable can’t be assigned to a pointer to int.
float floVar = 25.67;
int* ptrInt = &floVar; //ERROR: can’t assign float* to int*

20. Pointer to Void
 The address that is put in a pointer variable must be the
same type as the pointer, for example, the address of a float
variable can’t be assigned to a pointer to int.
float floVar = 25.67;
int* ptrInt;
ptrInt = &floVar; //ERROR: can’t assign float* to int*
 Exception to that case is a general-purpose pointer that can
point to any data type, e.g.,
void* ptrVoid; //pointer to void

21. Pointer to Void
 The address that is put in a pointer variable must be the
same type as the pointer, for example, the address of a float
variable can’t be assigned to a pointer to int.
float floVar = 25.67;
int* ptrInt;
ptrInt = &floVar; //ERROR: can’t assign float* to int*
 Exception to that case is a general-purpose pointer that can
point to any data type, e.g.,
void* ptrVoid; //pointer to void
ptrVoid = &floVar; //OK

22. Counting by Integers - Arrays

23. Passing Arguments to Functions
 Arguments can be passed to functions in three
different ways: (i) by value, (ii) by reference, and (iii) by
pointers
 A function can change the values in a calling function if
the arguments are passed by a reference or by a pointer.

24. Pass-by-Reference
void centimize(double& );
int main()
{ double var = 2.5;
centimize(var);
cout << var << endl;
getch(); return 0; }
void centimize(double& v)
{ v = v * 100; }

25. Pass-by-Pointer
void centimize(double* );
int main()
{ double var = 2.5;
centimize(&var);
cout << var << endl;
getch(); return 0; }
void centimize(double* ptrd)
{ *ptrd = *ptrd * 100; }

26. Pointer Passed to Function

27. Passing Arrays to Function
const int MAX = 5;
void centimize(double*); //prototype
int main()
{ double varray[MAX] = { 10.0, 43.1, 95.9, 59.7, 87.3 };
centimize(varray);
for(int j=0; j<MAX; j++)
cout << varray[j] << endl;
getch(); return 0; }
void centimize(double* ptrd)
{ for(int j=0; j<MAX; j++)
*ptrd++ = *ptrd * 2.54; } //*ptrd++ = *(ptrd++)

28. Pointer Passed to Function

29. Linked List
 Linked list is another way to store data besides storing
data in arrays.
 However, arrays suffer from the necessity to declare a
fixed-size array before running the program.