Pointer in programming in c for b.tech students

2
2
Address vs. Value
 Each memory cell has an address
associated with it
...
...
101 102 103 104 105 ...

3
3
Address vs. Value
 Each memory cell has an address
associated with it
 Each cell also stores some value
23 42 ...
...
101 102 103 104 105 ...

4
4
Address vs. Value
 Each memory cell has an address associated
with it
 Each cell also stores some value
 Don’t confuse the address referring to a memory
location with the value stored in that location
23 42 ...
...
101 102 103 104 105 ...

5
5
What is a pointer?
 First of all, it is a variable, just like other variables you
studied
 So it has type, storage etc.
 Difference: it can only store the address (rather than the
value) of a data item
 Type of a pointer variable – pointer to the type of the data
whose address it will store
 Example: int pointer, float pointer,…
 Can be pointer to any user-defined types also like structure types

 They have a number of useful applications
 Enables us to access a variable that is defined
outside the function
 Can be used to pass information back and forth
between a function and its reference point
 More efficient in handling data tables
 Reduces the length and complexity of a program
 Sometimes also increases the execution speed

7
7
Basic Concept
 As seen before, in memory, every stored data item
occupies one or more contiguous memory cells
 The number of memory cells required to store a data
item depends on its type (char, int, double, etc.).
 Whenever we declare a variable, the system allocates
memory location(s) to hold the value of the variable.
 Since every byte in memory has a unique address, this
location will also have its own (unique) address.

8
8
Contd.
 Consider the statement
int xyz = 50;
This statement instructs the compiler to
allocate a location for the integer variable xyz,
and put the value 50 in that location
Suppose that the address location chosen is
1380 xyz  variable
50  value
1380  address

9
9
Contd.
 During execution of the program, the system always
associates the name xyz with the address 1380
 The value 50 can be accessed by using either the
name xyz or the address 1380
 Since memory addresses are simply numbers, they
can be assigned to some variables which can be
stored in memory
 Such variables that hold memory addresses are
called pointers
 Since a pointer is a variable, its value is also
stored in some memory location

10
10
Contd.
 Suppose we assign the address of xyz to a
variable p
 p is said to point to the variable xyz
Variable Value Address
xyz 50 1380
p 1380 2545
p = &xyz;

11
11
Values vs Locations
 Variables name memory locations, which hold values
32
x
1024:
address
name
value

12
12
Pointers
A pointer is just a C variable whose value can contain the
address of another variable
Needs to be declared before use just like any other variable
General form:
data_type *pointer_name;
Three things are specified in the above declaration:
 The asterisk (*) tells that the variable pointer_name is
a pointer variable
 pointer_name needs a memory location
 pointer_name points to a variable of type data_type

13
13
Example
int *count;
float *speed;
char *c;
 Once a pointer variable has been declared, it can be made
to point to a variable using an assignment statement like
int *p, xyz;
:
p = &xyz;
 This is called pointer initialization

 Pointers can be defined for any type, including
user defined types
 Example
struct name {
char first[20];
char last[20];
};
struct name *p;
 p is a pointer which can store the address of a struct
name type variable

15
15
Accessing the Address of a
Variable
 The address of a variable is given by the & operator
 The operator & immediately preceding a variable
returns the address of the variable
 Example:
p = &xyz;
 The address of xyz (1380) is assigned to p
 The & operator can be used only with a simple variable
(of any type, including user-defined types) or an array
element
&distance
&x[0]
&x[i-2]

16
16
Illegal Use of &
 &235
 Pointing at constant
 int arr[20];
:
&arr;
 Pointing at array name
 &(a+b)
 Pointing at expression
In all these cases, there is no storage,
so no address either

17
17
Example
#include <stdio.h>
int main()
{
int a;
float b, c;
double d;
char ch;
a = 10; b = 2.5; c = 12.36; d = 12345.66; ch = ‘A’;
printf (“%d is stored in location %u n”, a, &a) ;
printf (“%f is stored in location %u n”, b, &b) ;
printf (“%f is stored in location %u n”, c, &c) ;
printf (“%lf is stored in location %u n”, d, &d) ;
printf (“%c is stored in location %u n”, ch, &ch) ;
return 0;
}

18
18
10 is stored in location 3221224908
2.500000 is stored in location 3221224904
A is stored in location 3221224891
Output

19
19
int a, b;
int *p;
p = &a;
b = *p;
Accessing a Variable Through
its Pointer
 Once a pointer has been assigned the address
of a variable, the value of the variable can be
accessed using the indirection operator (*).
Equivalent to b = a;

20
20
Example
#include <stdio.h>
int main()
{
int a, b;
int c = 5;
int *p;
a = 4 * (c + 5) ;
p = &c;
b = 4 * (*p + 5) ;
printf (“a=%d b=%d n”, a, b);
return 0;
}
Equivalent
a=40 b=40

21
21
Example
int main()
{
int x, y;
int *ptr;
x = 10 ;
ptr = &x ;
y = *ptr ;
printf (“%d is stored in location %u n”, x, &x);
printf (“%d is stored in location %u n”, *&x, &x);
printf (“%d is stored in location %u n”, *ptr, ptr);
printf (“%d is stored in location %u n”, y, &*ptr);
printf (“%u is stored in location %u n”, ptr, &ptr);
printf (“%d is stored in location %u n”, y, &y);
*ptr = 25;
printf (“nNow x = %d n”, x);
return 0;
}

22
22
Now x = 25
Address of x: 3221224908
Address of y: 3221224904
Address of ptr: 3221224900
Suppose that
Then output is

23
23
Example
32
x
1024:
int x;
int  xp ;
1024
xp
xp = &x ;
address of x
pointer to int
xp = 0; /* Assign 0 to x */
xp = xp + 1; /* Add 1 to x */

24
24
Value of the pointer
Declaring a pointer just allocates space to hold the
pointer – it does not allocate something to be pointed
to!
Local variables in C are not initialized, they may contain
anything
After declaring a pointer:
int *ptr;
ptr doesn’t actually point to anything yet. We can
either:
make it point to something that already exists, or
allocate room in memory for something new that it
will point to… (dynamic allocation, to be done later)

25
25
Example
Memory and Pointers:
0
1500
2300

26
26
int *p, v;
arbitrary value
0
arbitrary value 2300
p:
v: 1500

27
27
int v, *p;
p = &v;
arbitrary value
0
1500
1500 2300
p:
v:

28
28
int v, *p;
p = &v;
v = 17;
17
0
1500
1500 2300
p:
v:

29
29
int v, *p;
p = &v;
v = 17;
*p = *p + 4;
v = *p + 4
25
0
1500
1500 2300
p:
v:

30
30
More Examples of Using Pointers
in Expressions
 If p1 and p2 are two pointers, the following statements are
valid:
sum = *p1 + *p2;
prod = *p1 * *p2;
prod = (*p1) * (*p2);
*p1 = *p1 + 2;
x = *p1 / *p2 + 5;
 Note that this unary * has higher precedence than all
arithmetic/relational/logical operators
*p1 can appear on
the left hand side

31
31
Things to Remember
 Pointer variables must always point to a data item of the
same type
float x;
int *p;
:
p = &x;
will result in wrong output
 Never assign an absolute address to a pointer variable
int *count;
count = 1268;

32
32
Pointer Expressions
 Like other variables, pointer variables can
appear in expressions
 What are allowed in C?
Add an integer to a pointer
Subtract an integer from a pointer
Subtract one pointer from another (related)
 If p1 and p2 are both pointers to the same array, then
p2 – p1 gives the number of elements between p1 and
p2

33
33
Contd.
 What are not allowed?
Adding two pointers.
p1 = p1 + p2;
Multiply / divide a pointer in an expression
p1 = p2 / 5;
p1 = p1 – p2 * 10;

34
34
Scale Factor
 We have seen that an integer value can be
added to or subtracted from a pointer variable
int *p1, *p2;
int i, j;
:
p1 = p1 + 1;
p2 = p1 + j;
p2++;
p2 = p2 – (i + j);
 In reality, it is not the integer value which is
added/subtracted, but rather the scale factor times
the value

35
35
Contd.
Data Type Scale Factor
char 1
int 4
float 4
double 8
If p1 is an integer pointer, then
p1++
will increment the value of p1 by 4

37
37
 The scale factor indicates the number of bytes used to
store a value of that type
 So the address of the next element of that type can only be
at the (current pointer value + size of data)
 The exact scale factor may vary from one machine to
another
 Can be found out using the sizeof function
 Gives the size of that data type
 Syntax:
sizeof (data_type)

38
38
Example
int main()
{
printf (“No. of bytes in int is %u n”, sizeof(int));
printf (“No. of bytes in float is %u n”, sizeof(float));
printf (“No. of bytes in double is %u n”, sizeof(double));
printf (“No. of bytes in char is %u n”, sizeof(char));
printf (“No. of bytes in int * is %u n”, sizeof(int *));
printf (“No. of bytes in float * is %u n”, sizeof(float *));
printf (“No. of bytes in double * is %u n”, sizeof(double *));
printf (“No. of bytes in char * is %u n”, sizeof(char *));
return 0;
}
No. of bytes in int is 4
No. of bytes in float is 4
No. of bytes in double is 8
No. of bytes in char is 1
No. of bytes in int * is 4
No. of bytes in float * is 4
No. of bytes in double * is 4
No. of bytes in char * is 4
Output on a PC

 Note that pointer takes 4 bytes to store,
independent of the type it points to
 However, this can vary between machines
 Output of the same program on a server
 Always use sizeof() to get the correct size`
 Should also print pointers using %p (instead of %u
as we have used so far for easy comparison)
No. of bytes in int is 4
No. of bytes in float is 4
No. of bytes in double is 8
No. of bytes in char is 1
No. of bytes in int * is 8
No. of bytes in float * is 8
No. of bytes in double * is 8
No. of bytes in char * is 8

40
40
Example
int main()
{
int A[5], i;
printf(“The addresses of the array elements are:n”);
for (i=0; i<5; i++)
printf(“&A[%d]: Using %p = %p, Using %u = %u”, i, &A[i], &A[i]);
return 0;
}
&A[0]: Using %p = 0x7fffb2ad5930, Using %u = 2997705008
&A[3]: Using %p = 0x7fffb2ad593c, Using %u = 2997705020
Output on a server machine
0x7fffb2ad5930 = 140736191093040 in decimal (NOT 2997705008)
so print with %u prints a wrong value (4 bytes of unsigned int cannot
hold 8 bytes for the pointer value)

41
1400
1408
p
1407
p-1
double *p
‘c’
12
Printf(“%lf”,*p);
Printf (“%lf”,*(p-1));
18.76

42
Pointers and Arrays
 When an array is declared,
The compiler allocates sufficient amount of
storage to contain all the elements of the
array in contiguous memory locations
The base address is the location of the first
element (index 0) of the array
The compiler also defines the array name as
a constant pointer to the first element

43
Example
 Consider the declaration:
int x[5] = {1, 2, 3, 4, 5};
 Suppose that each integer requires 4 bytes
 Compiler allocates a contiguous storage of size 5x4 = 20
bytes
 Suppose the starting address of that storage is 2500
Element Value Address
x[0] 1 2500
x[1] 2 2504
x[2] 3 2508
x[3] 4 2512
x[4] 5 2516

44
Contd.
 The array name x is the starting address of the
array
 Both x and &x[0] have the value 2500
 x is a constant pointer, so cannot be changed
 X = 3400, x++, x += 2 are all illegal
 If int *p is declared, then
p = x; and p = &x[0]; are equivalent
 We can access successive values of x by using
p++ or p-- to move from one element to another

45
 Relationship between p and x:
p = &x[0] = 2500
p+1 = &x[1] = 2504
p+2 = &x[2] = 2508
p+3 = &x[3] = 2512
p+4 = &x[4] = 2516
 C knows the type of each element in array x, so
knows how many bytes to move the pointer to
get to the next element
In general, *(p+i)
gives the value of x[i]

46
Example: function to find
average
int main()
{
int x[100], k, n;
scanf (“%d”, &n);
for (k=0; k<n; k++)
scanf (“%d”, &x[k]);
printf (“nAverage is %f”,
avg (x, n));
return 0;
}
float avg (int array[], int size)
{
int *p, i , sum = 0;
p = array;
for (i=0; i<size; i++)
sum = sum + *(p+i);
return ((float) sum / size);
}

47
The pointer p can be subscripted
also just like an array!
int main()
{
int x[100], k, n;
scanf (“%d”, &n);
for (k=0; k<n; k++)
scanf (“%d”, &x[k]);
printf (“nAverage is %f”,
avg (x, n));
return 0;
}
float avg (int array[], int size)
{
int *p, i , sum = 0;
p = array;
for (i=0; i<size; i++)
sum = sum + p[i];
return ((float) sum / size);
}

Parameter passing
Difference for array (1D, 2D)
int main()
{
int x;
…..
………….
……..
foo(x);
…
}
void foo(int a)
{
…….
……..
}
x
a
int main()
{
int x[20];
…..
………….
……..
foo(x);
…
}
void foo(int a[])
{
…….
……..
}
x
a

int main()
{
int x;
…..
………….
……..
foo(x);
…
}
void foo(int a)
{
…….
……..
}
x
a
int main()
{
int x[20][20];
…..
………….
……..
foo(x);
…
}
void foo(int a[20][20])
{
…….
……..
}
x
a

50
Important to remember
 Pitfall: An array in C does not know its own length, &
bounds not checked!
 Consequence: While traversing the elements of an array (either
using [ ] or pointer arithmetic), we can accidentally access off the
end of an array (access more elements than what is there in the
array)
 Consequence: We must pass the array and its size to a function
which is going to traverse it, or there should be some way of
knowing the end based on the values (Ex., a –ve value ending a
string of +ve values)
 Accessing arrays out of bound can cause segmentation
faults
 Hard to debug (already seen in lab)
Always be careful when traversing arrays in programs

52
Pointers to Structures
 Pointer variables can be defined to store
the address of structure variables
 Example:
struct student {
int roll;
char dept_code[25];
float cgpa;
};
struct student *p;

53
 Just like other pointers, p does not point to
anything by itself after declaration
Need to assign the address of a structure to p
Can use & operator on a struct student type
variable
Example:
struct student x, *p;
scanf(“%d%s%f”, &x.roll, x.dept_code, &x.cgpa);
p = &x;

54
 Once p points to a structure variable, the
members can be accessed in one of two
ways:
(*p).roll, (*p).dept_code, (*p).cgpa
 Note the ( ) around *p
p –> roll, p –> dept_code, p –> cgpa
 The symbol –> is called the arrow operator
 Example:
 printf(“Roll = %d, Dept.= %s, CGPA = %fn”, (*p).roll,
(*p).dept_code, (*p).cgpa);
 printf(“Roll = %d, Dept.= %s, CGPA = %fn”, p->roll,
p->dept_code, p->cgpa);

55
Pointers and Array of Structures
 Recall that the name of an array is the
address of its 0-th element
Also true for the names of arrays of structure
variables.
 Consider the declaration:
struct student class[100], *ptr ;

56
 The name class represents the address of the 0-th
element of the structure array
 ptr is a pointer to data objects of the type struct
student
 The assignment
ptr = class;
will assign the address of class[0] to ptr
 Now ptr->roll is the same as class[0].roll. Same for
other members
 When the pointer ptr is incremented by one (ptr++) :
 The value of ptr is actually increased by sizeof(struct
student)
 It is made to point to the next record
 Note that sizeof operator can be applied on any data
type

57
A Warning
 When using structure pointers, be careful of
operator precedence
 Member operator “.” has higher precedence than “*”
 ptr –> roll and (*ptr).roll mean the same thing
 *ptr.roll will lead to error
 The operator “–>” enjoys the highest priority among
operators

++ptr –> roll will increment ptr->roll, not ptr
 (++ptr) –> roll will access (ptr + 1)->roll (for
example, if you want to print the roll no. of all elements of the
class array)

Pointer in programming in c for b.tech students

More Related Content

Similar to Pointer in programming in c for b.tech students

More from mbadepartment5

Recently uploaded

Pointer in programming in c for b.tech students