Post on 16-Oct-2021
M. RAVI KIRAN KUMAR MCA, M.Tech.
Govt. Degree College , Gummalakshmipuram
Email. Id: rkk.meduri@gmail.com
Computer Science/Applications
Programming in C
Objectives
At the end of the session, students should be able to
understand:
- Accessing addresses of 1-D array elements
- Array as a static pointer
- Using a dynamic pointer to access array elements
- Pointers and two-dimensional arrays
- Pointers to pointers and multi-level pointers
- Function pointers
- Benefits and drawbacks of pointers
Arrays
- An array is a collection of data of the same data type
organized in successive memory locations.
- Addresses of array elements are in arithmetic progression
and the difference between elements is the size of the data
type.
- Let us take an example and analyze.
Array Name - Significance
- What does the name of the array indicate?
- It indicates the starting address of the array i.e. the address
of the first element (indexed at 0).
Array – A Static Pointer
- Array name acts a pointer to the base address of the array
- Can be used to navigate through the array
- Cannot be incremented or decremented like a normal
pointer
&a[0] &a[1] &a[2] &a[3] &a[4]
a a+1 a+2 a+3 a+4
1 2 3 4 5
- a = &a[0], a + 1 = &a[1], a + 2 = &a[2], and so on, a + n = &a[n]
- *a = a[0], *(a + 1) = a[1], *(a + 2) = a[2], and so on, *(a + n) = a[n]
- a + n = &a[n]
- a++, a--, a = a – 5 or a = a + 5 are not valid
a+0
Using a Dynamic Pointer
- We can use a dynamic pointer to navigate through an array
- Declare a pointer of the same type as the array
- Perform arithmetic operations for navigation a a[1] a[2] a[3] a[4]
1 2 3 4 5
p p p p p
a[0]
Pointers – 2-D Arrays
- A 2-D array can be thought of as an array of 1-D arrays
- A 2-D array is stored in row major order i.e. data is stored
row by row
- First element in each row gives the starting address of the
row array.
- In an array a[m][n], a[i] gives the base address of ith row.
The address of jth element is a[i] + j * size.
- Likewise, element a[i][j] has the address a + i * n * size+
j * size where 0 <= i < m and 0 <= j < n
Pointers – 2-D Arrays
1 2 3
4 5 6
7 8 9
a[3][3]
Value
1
2
3
4
5
6
7
8
9
Address
0x7ffc0f94fe80
0x7ffc0f94fe84
0x7ffc0f94fe88
0x7ffc0f94fe8c
0x7ffc0f94fe90
0x7ffc0f94fe94
0x7ffc0f94fe98
0x7ffc0f94fe9c
0x7ffc0f94fea0
Row1
Row2
Row3
Example:
a[1][2]
= 0x7ffc0f94fe80(16) + (1 * 3 * 4 + 2 * 4) (10)
= 0x7ffc0f94fe80(16) + 20 (10)
= 0x7ffc0f94fe80(16) + 14 (16)
= 0x7ffc0f94fe94(16)
Pointers – 2-D Arrays - Illustration
Passing 1D Array Pointers to Functions - Since the name of the array holds the base address of the
array, we can pass it to a pointer along with its size
Passing 2D Array Pointers to Functions - 2D array name also indicates its base address but precisely
it is a pointer to an array of pointers.
- So, it needs type casting.
Pointers to Pointers - A pointer is also a variable – possesses an address
0x6040 0x1020 1000
var
0x1020
*ptr
0x6040
**ptr_to_ptr
0x9168 int var = 1000;
int *ptr = &var; //Stores the address of variable
int **ptr_to_ptr = &ptr; //Stores the address of pointer
printf (“var = %d\n”, var); //Direct access
printf (“var = %d\n”, *ptr); //Single indirection
printf (“var = %d\n”, **ptr_to_ptr); //Double indirection
- The address of a pointer variable can be stored in another pointer
variable - Called double pointer; Needs double indirection
Pointers to Pointers - Example
Multi Level Pointers - Pointers can be created in multiple levels
- We need multiple levels of indirection to access the values
stored. - Called triple pointer, quadruple pointer, etc.; Need multiple
indirections
- Difficult to maintain the code
How many levels?
- Logically, there is no limit
- Physically depends on the stack size
- If the stack size is 8 MB and the pointer size is 8 bytes, the number of
pointers is approx. 220. (subject to other pieces of code resident in
memory)
Function Pointers - We can also have pointers to functions in C
- A function pointer points to the starting address of the
executable code
- Function pointers cannot be allocated memory dynamically
- The name of a function can itself be used to get address of the
function; The operator & can also be used
- We can have an array of function pointers
- Functions can be passed as arguments to other functions using
function pointers
Function Pointers - Example
Benefits of Pointers
Pointers optimize the usage of memory space
Faster execution due to manipulation of
addresses
Memory can be dynamically allocated and
released
They are useful in representing complex data
structures
Useful to deal with files
Essential for system programming
Benefits
Drawbacks of Pointers
Uninitialized or null pointers cause
segmentation fault
Dynamic memory allocation may cause memory
leaks if not explicitly freed up.
Accessing incorrect memory locations through
pointers may cause software crashes
Pointer bugs are generally difficult to debug
Drawbacks
Summary Elements of an array are organized in consecutive memory
locations.
Name of an array represents the base address of the array;
Array name is a static pointer (constant) and cannot be used as
an lvalue.
Arrays can be passed to functions through pointers
Multi-level pointers need multi-level indirection
Pointers to functions can also declared in C
Pointers are useful in system programming
They suffer from memory leaks and segmentation faults
References Text Books:
- The C Programming Language – Brian W Kernighan and
Dennis M Ritchie – Second Edition
- Introduction to C Programming – Reema Thareja – Second
Edition
Web Links:
- http://www.toves.org/books/cptr/
- https://gribblelab.org/CBootCamp/8_Pointers.html