Pointers

Variable
A variable is a named memory
location.
Variables provide direct access to its
memory location.
A variable has a name, an address, a
type,and a value:
"the name identifies the variable to the
programmer
"the address specifies where in main
memory the variable is located
What is a variable?
"the type specifies how to
interpret the data stored in main
memory and how long the
variable is
"the value is the actual data
stored in the variable after if has
been interpreted according to a
given type
 Pointer variable
A pointer is a variable that contains the
memory location of another variable.
Syntax:-
type * variable name
You start by specifying the type of data
stored in the location identified by the
pointer.
The asterisk tells the compiler that you are
creating a pointer variable.
Finally you give the name of the variable.
Declaring a Pointer
Variable
 To declare ptr as an integer
pointer:
int *ptr;
 To declare ptr as a character
pointer:
char *ptr;
Address operator:
Once we declare a pointer variable we
must point it to something we can do
this by assigning to the pointer the
address of the variable you want to
point as in the following example:
ptr=#
This places the address where num is
stores into the variable ptr. If num is
stored in memory 21260 address then
the variable ptr has the value 21260.
 Address and Pointers
Memory can be
conceptualized as ADDR1 Contents1
a linear set of ADDR2
ADDR3
data locations. ADDR4
ADDR5
Variables ADDR6
*
reference the *
contents of a *

locations ADDR11 Contents11

Pointers have a *
value of the *

address of a given ADDR16 Contents16

location
Lect 14 P. 7
 Pointer Variable
Assume ptr is a pointer variable and x is an integer variable

x 10

ptr &x

Now ptr can access the value of x.

HOW!!!!
x = 10
Write: *variable . For example:

ptr = &x printf(“%d\n”, *ptr);

Can you tell me why we put %d????

Variables, Addresses and
Pointers

main() Memory

{ Value
a (1001) 5
int a = 5;
b (1003) 6
int b = 6;
c (1005)
int *c;
// c points to a 1001
c = &a;
}
include< stdio.h >
{
int num, *intptr;
float x, *floptr;
char ch, *cptr;
num=123;
x=12.34;
ch=’a’;
intptr=&num;
cptr=&ch;
floptr=&x;
printf(“Num %d stored at address %u\
n”,*intptr,intptr);
printf(“Value %f stored at address %u\
n”,*floptr,floptr);
printf(“Character %c stored at address %u\
n”,*cptr,cptr);
}
Run this code
int main()
{
int x;
int *ptr;

x = 10;
ptr = &x;
*ptr = *ptr + 1;
printf(“x = %d\n”, x);
}
 Manipulating Pointer
Variable
Once a variable is declared, we can get its
address by preceding its name with the
unary & operator, as in &k.
We can "dereference" a pointer, i.e. refer to
the value of that which it points to, by using
the unary '*' operator as in *ptr
Reference
 Reference &
 Retrieve the memory address of a variable
 int a = 6;
 int* c = &a; // &a is the memory location of
variable a
 Dereference
Dereference * Accessing the variable
(content) the pointer points to
(Indirection)
int a = 6;
int* c = &a;
*c = 7; /* Changes content of variable
a by using its address stored in
pointer c */
equivalent to
a = 7;
 Constant Pointers
A constant pointer, ptr, is a
pointer that is initialized with an
address, and cannot point to
anything else.
We can use ptr to change the
contents of value
Example
int value = 22;
int * const ptr = &value;
CIS 15 Pointer Arithmetic 15
 Constant Pointer
 Constant pointer means the pointer is
constant. Constant pointer is NOT pointer to
constant.
 For eg:
int * const ptr2 indicates that ptr2 is a
pointer which is constant. This means that ptr2
cannot be made to point to another integer.
 However the integer pointed by ptr2 can be
changed.
 //const pointer void
main()
{
int i = 100,k;
int* const pi = &i;
*pi = 200;
pi=&k; //won't compile
}
 Constant Pointers to
Constants
 A constant pointer to a constant is:
a pointer that points to a constant
a pointer that cannot point to
anything except what it is pointing to

 Example:
int value = 22;
const int * const ptr =
&value;

CIS 15 Pointer Arithmetic 18

//const pointer to a const void
f3()
{
int i = 100;
const int* const pi = &i;
//*pi = 200; <- won't compile
//pi++; <- won't compile
}
Pointer to constant
Pointer to constant is
const int * ptr1 indicates that
ptr1 is a pointer that points to a
constant integer. The integer is
constant and cannot be changed.
However, the pointer ptr1 can be
made to point to some other
integer.
//pointer to a const
void f1()
{
int i = 100;
const int* pi = &i;
//*pi = 200; <- won't compile
pi++;
}m
Pointer arithmetic
Valid operations on pointers
include:
- the sum of a pointer and an
integer
- the difference of a pointer and an
integer
- pointer comparison
-the difference of two pointers.
-Increment/decrement in pointers
- assignment operator used in
pointers
Example
void main()
{
int a=25,b=78,sum;
int *x,*y;
x=&a;
y=&b;
sum= *x + *y;
printf(“Sum is : %d”,sum);
}
Assignment in pointers

Pointervariables can be
"assigned":
int *p1, *p2;
p2 = p1;
◦ Assigns one pointer to another
◦ "Make p2 point to where p1 points"
Do not confuse with:
*p1 = *p2;
◦ Assigns "value pointed to" by p1, to
"value
pointed to" by p2
Diagrammatic
representation
Comparison in pointers
Two pointers of the same type, p and q,
may be compared as long
as both of them point to objects within a
single memory block
• Pointers may be compared using the <, >,
<=, >=, == , !=
• When you are comparing two pointers, you
are comparing the
values of those pointers rather than the
contents of memory locations pointed to by
these pointers
Increment and
decrement
Data Type Initial Operation Address Required
address after bytes
operation
s
Int i=2 4046 ++ -- 404 404 2bytes
8 4
Char c=‘x’ 4053 ++ -- 405 404 1bytes
4 2
Float f=2.2 4050 ++ -- 405 404 4bytes
4 6
Long l=2 4060 ++ -- 406 405 4bytes
4 6
 You can perform a limited number of arithmetic operations
on pointers. These operations are:
 Increment and decrement
 Addition and subtraction
 Comparison
 Assignment
 The increment (++) operator increases the value of a
pointer by the size of the data object the pointer refers to.
For example, if the pointer refers to the second element in
an array, the ++ makes the pointer refer to the third
element in the array.
 The decrement (--) operator decreases the value of a
pointer by the size of the data object the pointer refers to.
For example, if the pointer refers to the second element in
an array, the -- makes the pointer refer to the first element
in the array.
 You can add an integer to a pointer but you cannot add a
pointer to a pointer.
 If the pointer p points to the first element in an array, the
following expression causes the pointer to point to the third
element in the same array:
 p = p + 2; If you have two pointers that point to the same
array, you can subtract one pointer from the other. This
operation yields the number of elements in the array that
separate the two addresses that the pointers refer to.
 You can compare two pointers with the following
operators: ==, !=, <, >, <=, and >=.
 Pointer comparisons are defined only when the pointers
point to elements of the same array. Pointer comparisons
using the == and != operators can be performed even
when the pointers point to elements of different arrays.
 You can assign to a pointer the address of a data object, the
value of another compatible pointer or the NULL pointer.
 Pointer Arithmetic
Operations on pointer variables:
Operation Example
int vals[]={4,7,11};
int *valptr = vals;
++, -- valptr++; // points at 7
valptr--; // now points at 4
+, - (pointer and int) cout << *(valptr + 2); // 11

+=,-= (pointer and int) valptr = vals; // points at 4

valptr += 2; // points at 11

CIS 15 Pointer Arithmetic 30

 Generic pointers
When a variable is declared as being a
pointer to type void it is known as a
generic pointer.
 Since you cannot have a variable of type
void, the pointer will not point to any
data and therefore cannot be
dereferenced.
It is still a pointer though, to use it you
just have to typecast it to another kind of
pointer first. Hence the term Generic
pointer.
This is very useful when you want a
pointer to point to data of different
types at different times.

Syntax:
void * variable name;

Print value stored in variable

*(data_type*)name of variable;
void main()
{ int i;
char c;
void *data;
i = 6;
c = 'a';
data = &i;
printf("the_data points to the integer value %d\
n", *(int*) data);
data = &c;
printf("the_data now points to the character %c\n",
*(char*) data);
}
 Null Pointer
NULL value can be assigned to any
pointer, no matter what its type.
void *p = NULL;
int i = 2;
int *ip = &i;
p = ip;
printf("%d", *p);
printf("%d", *((int*)p ) );
Pointers and Arrays
The concept of array is very much
bound to the one of pointer. In fact,
the identifier of an array is equivalent
to the address of its first element, as
a pointer is equivalent to the address
of the first element that it points to,
so in fact they are the same concept.
Pointers and Arrays
Pointers have close relationship
with array .
An array name by itself is an
address or pointer.
Pointers are linked with both
types of array
◦ A)one dimensional array pointer
◦ B)two dimensional array pointer
For example,
int numbers [20]; int * p;

The following assignment

operation would be valid:

p = numbers;
After that, p and numbers would be equivalent
and would have the same properties. The only
difference is that we could change the value
of pointer p by another one, whereas
numbers will always point to the first of the
20 elements of type int with which it was
defined. Therefore, unlike p, which is an
ordinary pointer, numbers is an array, and an
array can be considered a constant pointer.
#include <stdio.h>
main ()
{ int numbers[5];
int * p;
p = numbers;
*p = 10;
p++;
*p = 20;
p = &numbers[2];

Cont…
…cont.

*p = 30;
p = numbers + 3;
*p = 40; p = numbers;
*(p+4) = 50;
for (int n=0; n<5; n++)
printf(“%d”, numbers[n]);
}
In arrays we used brackets ([]) several
times in order to specify the index of an
element of the array to which we
wanted to refer. Well, these bracket
sign operators [] are also a
dereference operator known as offset
operator. They dereference the variable
they follow just as * does, but they also
add the number between brackets to
the address being dereferenced
For example:
a[5] = 0; // a [offset of 5] = 0
*(a+5) = 0; // pointed by (a+5) =
0

These two expressions are

equivalent and valid both if a is a
pointer or if a is an array.
Example of 1D array
Void main()
{
int a[5]={1,2,3,4,5};
int *p,i;
p=&a;
printf(“displaying data using pointer ”);
for(i=0;i<5;i++)
{
printf(“%d”,*(p+i));
}
printf(“displaying data using array name ”);
for(i=0;i<5;i++)
{
printf(“%d”,*(a+i));
}
}
Example of 2D array
Void main()
{
int a[5][2]={ {1,2},{3,4},{5,6},{7,8},{9,10} };
int *p,j,i;
p=&a;
printf(“displaying data using pointer ”);
for(i=0;i<5;i++)
{
for(j=0;i<2;j++)
{
printf(“%d”,*(*(p+i)+j));
}
printf(“\n”);
}
}
Pointers and Character
String
void main()
{
char name[] = “sanjima”;
char *ptr;
int i=0;count=0;
ptr=&name;
while(*(ptr+i)!=‘\0’)
{
count++;
i++;
}
printf(“length of string is %d ”,count);
getch();
Example
void main()
{
char str1[]=“hello”;
char str2[10];
char *s= “Good Morning”;
char *q;

str2=str1; /error/
q= s; /works/
return;
}
Array of pointers
 It is nothing but a collection of address.
Void main()
{
int a[5]={1,2,3,4,5},i;
int *p[5];
for(i=0;i<5;i++)
{
p[i]=a+i;
}
for(i=0;i<5;i++)
{
printf(“%d value”,*(p+i));
printf(“at location %u”,p+i)
}
}
Pointers to pointers
A pointer variable containing
address of another pointer variable
is called pointer to pointer
void main()
{
int a=2, *p, **q;
p=&a;
q=&p;
printf(“%d value is stored at %u and
pointer is stored at %u”,a,p,q);}
Difference between *p[3] and (*p)
[3]

*p[3] declares p as an array of 3

pointers

(*p)[3] declares p as a pointer to an

array of 3 elements
*(p+2)