0% found this document useful (0 votes)

48 views53 pages

Data Structures: Lecture 3: Pointer

This document provides an overview of pointers in C++. It defines pointers as variables that store memory addresses and explains how they allow indirect access to values in memory. Key points include: - Pointers must be declared before use and are declared using an asterisk. - They can be assigned memory addresses using the address of operator (&). - The dereference operator (*) accesses the value at the memory address stored in the pointer. - Pointers enable passing variables to functions by reference and are essential for building complex data structures like linked lists.

Uploaded by

Hard Fucker

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PPT, PDF, TXT or read online on Scribd

0% found this document useful (0 votes)

48 views53 pages

Data Structures: Lecture 3: Pointer

Uploaded by

Hard Fucker

We take content rights seriously. If you suspect this is your content, claim it here.

Available Formats

Download as PPT, PDF, TXT or read online on Scribd

You are on page 1/ 53

CSC 2105 Data Structures

Lecture 3: Pointer
Pointers

– Powerful feature of the C++ language

– Essential for construction of interesting data

structures

2
&

• The address of a memory location is called a pointer.

• Every variable is assigned a memory location whose address
of this memory location can be retrieved using address
operator & of C++.

Following figure shows their memory arrangement and addresses:

&letter is 1200 , &number is 1201, &amount is 1203
Example
#include <iostream.h>
value FFF0 56.47
void main( ) FFF1
{ FFF2
int data = 100;
float value = 56.47; FFF3
cout << data << &data << endl; data FFF4 100

cout << value << &value << endl; FFF5

} FFF6

Output:
100 FFF4
56.47 FFF0
OR

Like any variable or constant, you must declare a pointer before you can use it
to store any variable address.
Declaration of Pointer Variables
Type *pointerVarName;
– The * before the pointerVarName indicates that this
is a pointer variable, not a regular variable

– The * is not a part of the pointer variable name

Some valid pointer declaration:

int *inp; // pointer to an integer
char *chp // pointer to a character
double *dp; // pointer to a double
float *flp; // pointer to a float
The pointer data type
 A data type for containing an address (hexadecimal
number ) rather than a data value

 Provides indirect access to values

 The actual data type of the value of all pointers,

(integer, float, character) is the same, a long
hexadecimal number that represents a memory
address.

 The only difference between pointers of different data

types is the data type of the variable that the pointer
points to.
Declaration of Pointer Variables (Cont ..)
• Whitespace doesn‘t matter and
• each of the following will declare
– ptr as a pointer (to a float) variable and
– data as a float variable

float *ptr, data;

float* ptr, data;
float (*ptr), data;
float data, *ptr;
Assignment of Pointer Variables
• A pointer variable has to be assigned a valid
memory address before it can be used in the
program
• Example:
float data = 50.8;
float *ptr;
ptr = &data;
– This will assign the address of the memory
location allocated for the floating point
variable data to the pointer variable ptr.

– This is valid, since the variable data has

already been allocated some memory space
having a valid address
Assignment of Pointer Variables (Cont
..)

FFF0
FFF1
float data = 50.8; FFF2
float *ptr;
FFF3
ptr = &data;
data FFF4 50.8
FFF5
FFF6

10
Assignment of Pointer Variables (Cont
..)

ptr FFF0
FFF1
float data = 50.8; FFF2
float *ptr;
FFF3
ptr = &data;
data FFF4 50.8
FFF5
FFF6

11
Assignment of Pointer Variables (Cont
..)

ptr FFF0 FFF4

FFF1
float data = 50.8; FFF2
float *ptr;
FFF3
ptr = &data;
data FFF4 50.8
FFF5
FFF6

12
Assignment of Pointer Variables (Cont
..)
• Don’t try to assign a specific integer value to a
pointer variable since it can be disastrous
float *ptr;
ptr = 120; //This is wrong.
h they are both integrals
float data = 50.0;
float *ptr;
ptr = &data; //This is valid
Initializing pointers
• A pointer can be initialized during declaration by
assigning it the address of an existing variable
float data = 50.8;
float ptr = &data;
• If a pointer is not initialized during declaration, it
is wise to give it a NULL (0) value

float *fp = NULL;

14
The NULL pointer
• The NULL pointer is a valid address for
any data type.
– But NULL is not memory address 0.
• It is an error to dereference a pointer
whose value is NULL.
– Such an error may cause your program to
crash, or behave erratically.
– It is the programmer’s job to check for this.
Dereferencing
• Dereferencing – Using a pointer variable
to access the value stored at the location
pointed by the variable
– Provide indirect access to values and also called
indirection
• Done by using the dereferencing operator
* in front of a pointer variable
– Unary operator
– Highest precedence
Dereferencing (Cont ..)
• Example:
float data = 50.8;
float *ptr;
ptr = &data;
cout << *ptr;
• Once the pointer variable ptr has been declared,
*ptr represents the value pointed to by ptr.

OUTPUT:
50.8
Dereferencing (Cont ..)
• The dereferencing operator * can also be used
in assignments.
*ptr = 200;
– Make sure that ptr has been properly initialized
float data;
float *ptr;
ptr = &data;
*ptr = 200;
cout << *ptr;
OUTPUT:
200
Dereferencing Example
#include <iostream.h>
ptr FFF0 FFF4
void main()
{ FFF1
float data = 50.8;
float *ptr; FFF2
ptr = &data; FFF3
cout << ptr << *ptr << endl;
*ptr = 27.4; data FFF4 50.8
cout << *ptr << endl;
FFF5
cout << data << endl;
} FFF6

Output:
#include <iostream.h>

void main()
{
float data = 50.8; ptr FFF0 FFF4
float *ptr;
ptr = &data; FFF1
cout << ptr <<“ ”<< *ptr << endl;
*ptr = 27.4; FFF2
cout << *ptr << endl; FFF3
cout << data << endl;
} data FFF4 50.8
FFF5
OUTPUT: FFF6
FFF4 50.8
Dereferencing Example (Cont ..)
#include <iostream.h>

void main()
{
float data = 50.8; ptr FFF0 FFF4
float *ptr;
ptr = &data; FFF1
cout << ptr <<“ ”<< *ptr << endl;
*ptr = 27.4; FFF2
cout << *ptr << endl; FFF3
cout << data << endl;
} data FFF4 27.4
FFF5
OUTPUT: FFF6
FFF4 50.8
Dereferencing Example (Cont ..)
#include <iostream.h>

void main()
{ ptr FFF0 FFF4
float data = 50.8;
float *ptr; FFF1
ptr = &data;
FFF2
cout << ptr << *ptr << endl;
*ptr = 27.4; FFF3
cout << *ptr << endl;
cout << data << endl; data FFF4 27.4
} FFF5

OUTPUT: FFF6
27.4
Dereferencing Example (Cont ..)
#include <iostream.h>
ptr FFF0 FFF4
void main()
{ FFF1
float data = 50.8;
float *ptr; FFF2
ptr = &data; FFF3
cout << ptr << *ptr << endl;
*ptr = 27.4; data FFF4 27.4
cout << *ptr << endl;
FFF5
cout << data << endl;
} FFF6

OUTPUT
???
// more pointers
#include <iostream>
using namespace std;

int main ()
{
int firstvalue = 5, secondvalue = 15;
int * p1, * p2;

p1 = &firstvalue; // p1 = address of firstvalue

p2 = &secondvalue; // p2 = address of secondvalue
*p1 = 10; // value pointed to by p1 = 10
*p2 = *p1; // value pointed to by p2 = value pointed by p1
p1 = p2; // p1 = p2 (value of pointer is copied)
*p1 = 20; // value pointed by p1 = 20

cout << "firstvalue is " << firstvalue << '\n';

cout << "secondvalue is " << secondvalue << '\n'; firstvalue is 10
return 0; secondvalue is 20
}
Why Pointers?

• To modify a variable in a function that is

not a global, or a local to that function
• To save space
• To save time
• To use dynamic memory (Lecture A6)
• Used extensively in linked structures
Passing pointers to a function
#include <iostream>
Solution 1
void fakeSwap(int a, int b)
{
int tmp;

tmp = a;
a = b;
b = tmp;
}

int main()
{
int x = 1, y = 2;

fakeSwap(x, y);
cout << x << " " << y << endl;
}