Scribd
Upload
18 views

Lect 18 Pointers Arrays Structures

When an array is declared, the compiler allocates contiguous memory for all elements and the array name is a pointer to the first element. Pointers can be used to iterate through arrays using pointer arithmetic. Pointers can also be used to access structures and elements within structures can be accessed using the -> operator or (*pointer).name syntax. When an array of structures is declared, the array name is a pointer to the first structure in the array.

Uploaded by

praween k
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
18 views

Lect 18 Pointers Arrays Structures

When an array is declared, the compiler allocates contiguous memory for all elements and the array name is a pointer to the first element. Pointers can be used to iterate through arrays using pointer arithmetic. Pointers can also be used to access structures and elements within structures can be accessed using the -> operator or (*pointer).name syntax. When an array of structures is declared, the array name is a pointer to the first structure in the array.

Uploaded by

praween k
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 15

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

You might also like