Lect 18 Pointers Arrays Structures

Pointers and Arrays
1
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
2
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
3
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
4
 Relationship between p and x:
p = &x[0] = 2500
p+1 = &x[1] = 2504 In general, *(p+i) gives
p+2 = &x[2] = 2508 the value of x[i]
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
5
Example: function to find
average
int main()
{
int x[100], k, n;
float avg (int array[], int size)
scanf (“%d”, &n); {
int *p, i , sum = 0;
for (k=0; k<n; k++)
scanf (“%d”, &x[k]); p = array;
printf (“\nAverage is %f”, for (i=0; i<size; i++)

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

avg (x, n)); sum = sum + p[i];
return 0;
} return ((float) sum / size);
}
7
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
8
Pointers to
Structures
9
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;
10
 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;
11
 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 = %f\n”, (*p).roll,
(*p).dept_code, (*p).cgpa);
 printf(“Roll = %d, Dept.= %s, CGPA = %f\n”, p->roll,
p->dept_code, p->cgpa);
12
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 ;
13
 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
14
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)
15

Lect 18 Pointers Arrays Structures

Uploaded by

Copyright:

Available Formats

Lect 18 Pointers Arrays Structures

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Lect 18 Pointers Arrays Structures

Uploaded by

Copyright:

Available Formats

Pointers and Arrays

 When an array is declared,

Element Value Address

 If int *p is declared, then

printf (“\nAverage is %f”, for (i=0; i<size; i++)

printf (“\nAverage is %f”, for (i=0; i<size; i++)

struct student x, *p;

struct student class[100], *ptr ;

 The operator “–>” enjoys the highest priority

You might also like