C Programming : Pointers and Arrays, Pointers and Strings

UNIT I : Pointers and Arrays, Pointers
and Strings
By
Mr.S.Selvaraj
Asst. Professor (SRG) / CSE
Kongu Engineering College
Perundurai, Erode, Tamilnadu, India
Thanks to and Resource from : Sumitabha Das, “Computer Fundamentals and C Programming”, 1st Edition, McGraw Hill, 2018.
20CST21 – Programming and Linear Data Structures

Preamble and Course Outcomes
4/21/2021 1.0 _ Pointers and Arrays 2

Syllabus – Unit Wise

List of Exercises

Text Book and Reference Book

Unit I : Contents
1. Pointers- Introduction
2. Pointers and 1D array
3. Passing an array to a function
4. Returning an array from function
5. NULL pointers
6. Array of pointers
7. Pointer-to-pointer
9. Generic pointers
10. Dangling Pointer
11. Using Pointers for string manipulation
12. Two dimensional array of strings
13. Array of pointers to strings.
4/21/2021 6
1.0 _ Pointers and Arrays

Pointers- Introduction
• Every variable in C language has a name and a
value associated with it.
• When a variable is declared, a specific block
of memory within the computer is allocated
to hold the value of that variable.
• Each memory location has a distinct address.

• For example,
– we live in a house and our house has an address,
which helps other people to identify our house.
• The same way the value of the variable is
identified using the address of that variable.
• This address of the variable or memory location
can be stored in a pointer.

• Using pointer we can have direct access to a
memory location because they store address
of a variable or memory location.
• Pointers are closely related to low level
memory operations.
• Before introducing the pointers in
programming, let us understand what
happens during a variable definition.

• Let us consider the following statement :
• When the above statement is compiled and
executed, the following will happen:
– The compiler allocates memory to store an integer.
– Next , compiler assigns a label to the allocated
memory location as n.
– Finally, the constant 10 is stored in that location.

Advantages of Pointers
• Pointers provide direct access to memory.
• Pointers are used to return more than one value from
a function.
• Pointers allow dynamic memory allocation and
deallocation.
• Reduces the storage space required by the program.
• Pointers are more efficient in handling arrays and
structures.
• Pointers are used to get reference of a variable or
function.
• Pointers increases program execution speed.
• Pointer allows to create complex data structures such
as linked list, stack, queues, trees, graphs etc.

• Pointer is a variable which stores the address
of another variable.
• It is used to allocate memory dynamically.
• Memory allocation done at run time is known
as Dynamic memory allocation.
• Pointer variable may be any valid C data type
such as int, float, double, char etc.
• For any type of pointers, only four bytes of
memory is allocated for storing the address.

Example

Pointer Declaration
• Pointer can be declared with a variable preceded by *.
• Pointer can be declared using the following syntax:

Pointer operators
• Reference or Address of operator (&)
• Dereference operator or indirection operator
or Value at Address Operator (*)

Reference Operator - Example

Dereference operator (*)
• To access the value at the address stored in the
pointer variable, we can use dereference
operator (*).
• This is an unary operator * that returns the value
of the variable located at the address specified by
its operand.

Dereference Operator - Example

Example 1

Swapping using function and pointers
• we have to use pointers concept.
• Bz,
– Parameters are always passed by value in C and
– function can not return more than one value.

Example 2

Example 3

Pointer Arithmetic
• A pointer is a variable which holds the address of another
variable.
• Address is represented by a numeric value.
• We cannot perform every type of arithmetic operation on
pointers.
• The following arithmetic operations are the only valid
arithmetic operations performed on pointers:

Pointer Arithmetic
• For example, assume the integer pointer ptr
which contains the address 1000.
• If we are incrementing the pointer ptr by 1 (using
++ptr or ptr++), we will get 1002 (i.e 1000 + 1 * 2)
• Instead of 1001 because the size of the int data
type is 2 bytes (Note: Size of the datatype
changes depends on the compiler used).
• If we are using a system where the size of int is 4
bytes then we would get 1004 ( i.e 1000 + 1 * 4 ).

Pointer Arithmetic - Example
• Suppose the address of the variables i, f and ch are
1000, 2000 , 3000 respectively. Therefore iptr, fptr and
cptr will have initial values of 1000, 2000 and 3000.
Assume 1, 2 and 4 bytes of memory is allocated for
char, int and float variables respectively.

Example 4 - Print all the alphabets using pointer

Example 5 - Add two integers using pointers

Example 6 - Add two integers using function by
passing address of two numbers as arguments
to function.

Pointer Arithmetic between Two Pointers
• Arithmetic operation between two pointers is
performed only on same type of pointers.
• Let us take two integer pointers ptr1 and ptr2
with addresses 1000 and 1008 respectively.
• The expression ptr2 - ptr1 will give the result
as 4, since the memory location allocated for
integer data type is 2 bytes.
• If we subtract ptr2 from ptr1 i.e the
expression (ptr1 - ptr2) will give the result -4.

Example 7

Thank you

Unit I : Contents
5. NULL pointers
9. Generic pointers
4/21/2021 37
2.0 _ Pointers and Arrays

Pointers and Arrays
• We are already familiar with arrays, which store multiple values of
the same data type.
• Array elements are stored in contiguous memory locations.
• When an array is declared, compiler allocates required amount of
contiguous memory locations to hold all the elements of the array.
• Memory is allocated by the compiler during compilation time itself.
• Base address of the array is the address of the first element of the
array.
• We can create a pointer which can be used to point an array.
• In an one dimensional array, we can use single subscript to access
the array elements.
• Name of the 1-D array or &array[0] points to the address of the
first element of an array.

Pointers and 1D Arrays
• Suppose we declare an integer array “A” with 5
elements and assuming that the base address of the
array a is 1000 and each integer element requires two
bytes of memory.
• The five elements will be stored as follows:
• Here array name “A” acts as a constant pointer which
will give the base address of the array and points to
the first element of the array, A[0].
– i.e., the value of A and &A[0] are same.

Pointers and 1D Arrays
• We can declare another pointer of type int to point to the
array A.
• Now we can access every element of the array A using
pointer p.
• (*p) is used to access the element A[0] which has the value
1 in the given example.
• To access the next element in the array A,
– increment the pointer p by 1 using (p++) or (++p).
– Now we can give *p to get A[1].
– It gives the value 2.
– To get the next element in the array A, increment the pointer p
by 1 and use *p.

Example 1- Program to demonstrates the use of
pointer to access the array elements

Example 2- use array name as a pointer to
access the array elements

• In the above program, A is a constant pointer which always
points to first element A[0].
• We cannot move this pointer to next element using ++
operator since base address of the array cannot be
changed.
• To access the elements of the array using a constant
pointer A, we can use the following statements:

Example 3- Program to display the elements of
an array in reverse order using pointer.

Example 4 – Program to add the elements of an
array using pointer

Example 5 – Program to demonstrate increment and
decrement operators with pointers and arrays.

Example 6 - Program to copy an array to another array
using pointers

Thank you

Unit I : Contents
6. NULL pointers
9. Generic pointers
4/21/2021 50
2.0 _ Passing and Returing an array
to_from a function

Passing an array to a function
• We can pass an individual elements or entire
array to a function as an argument.
• To pass an entire array to a function, only the
name of the array is passed as an argument.
• When address is passed as an argument, the
function definition should have an array or a
pointer as a parameter to receive the passed
address.
• When an array is passed to a function, the
changes made by the function affect the original
array.
4/21/2021
to_from a function
51

Function Definition with array as a
parameter
• We can receive an array in a function using one of
the following two methods.
• The name of the array is passes as an argument,
which is the address of the first element of the
array.
4/21/2021
to_from a function
52

Example 1 – Program to demonstrate the
average of all the elements of an array.
4/21/2021
to_from a function
53

Method 1
4/21/2021
to_from a function
54

Method 2
4/21/2021
to_from a function
55

Method 3
4/21/2021
to_from a function
56

Example 2 - Write a program in C to
sort an array using Pointer
4/21/2021
to_from a function
57

Returning an array from a function
• C does not allow to return an entire array
from a function.
• However, we can return a pointer to the base
address(address of first element of array) of
an array by specifying the name of the array
without an index.
4/21/2021
to_from a function
58

• If we want to return a 1-D array from a
function, we have to declare a function
returning a pointer as in the following
example :
4/21/2021
to_from a function
59

• We should not return base pointer of a local
array declared inside a function because as
soon as control returns from a function all
local variables gets destroyed.
• If we want to return a local array then we
should declare it as a static variable so that it
retains it's value after function call.
4/21/2021
to_from a function
60

Example 2 - Program to generate first N
even numbers and return as an array.
4/21/2021
to_from a function
61

4/21/2021
to_from a function
62

Thank you
4/21/2021
to_from a function
63

Unit I : Contents
7. NULL pointers
9. Generic pointers
4/21/2021 65
1.4 _ Pointers and 2D Arrays

Pointers and 2D array
• In a two dimensional array, we can access
each element by using two subscripts.
– first subscript represents the row number and
– second subscript represents the column number
• Consider the following declaration statement,
4/21/2021 1.4 _ Pointers and 2D Arrays 66

• The above declaration statement creates a
3x4 matrix initialized with the following
values:

• The element at ith row, jth column can be accessed
using a[i][j].
• To access the value 7, we have to use a[1][2].
• Let us see how pointer is used to access the 2-D array.
• As we know, name of the array gives the base address
of the array i.e., address of a[0][0].
• To access a[i][j] using base pointer of the array, we can
use the following generalized form:

• The following figure shows how the above 2-D array
will be stored in memory.
• Array elements are stored in memory row by row.

• In a 2-D array, each row will be considered as a one
dimensional array.
• Hence 2-D array can be considered as a collection of
several one dimensional arrays.
• In this example, each row is an array of 4 integers.
• We know that the name of an array is a constant pointer
that points to 0th row which contains address 1000.

• Consider a two dimensional array mat[ROWS] [COLS]
where ROWS and COLS are some integer value.
• We can use any one of the following two notations to
access the two dimensional array.
• The first int mat[][COLS] is general array notation.
• Whereas int (*mat)[COLS] is a pointer to array.

Example - read and display a 3x3 matrix

Passing a 2D array to a function
• For passing multidimensional arrays,
– First array dimension does not have to be
specified.
– The second dimension must be explicitly
specified or a pointer to pointer as a parameter
to receive the address.

Example - print 2-D array using function

Example - add two 3 x 3 matrices using pointer

Example - display Lower triangular and Upper
triangular of a given matrix of size mxn

Example - to print and find sum of diagonal
elements of a given matrix.

Returning a 2D array from Function
• Returning a 2D array from function is not as straight as
passing an array to a function.
• Arrays in C are passed by reference, hence any changes
made to array passed as argument persists after the
function.
• So you can accept the output array you need to return, as a
parameter to the function.
• The following program demonstrates how a 2-D array is
returned from a function by passing resultant array also as
a parameter.
• In the following program, main() receives two matrices as
input and these two matrices along with resultant matrix
are passed as arguments to the function sum().
• The sum() function adds the two matrices and return the
resultant matrix as result to the main() function.

Further Reference
To
Pass and Return an array(1D & 2D) to / from function
with/without using pointers
please refer
this
link......
• https://codeforwin.org/2017/12/pass-return-
array-function-c.html#return-array-multi

Thank you

Unit I : Contents
7. NULL pointers
9. Generic pointers
4/21/2021 100
1.5 _ Pointers Concepts

Array of Pointers
• When we want to maintain an array to store the
address of memory locations of type int or float
or char or any other data type available, we have
to create an array of pointers.
• Here is the syntax to declare an array of pointers
which is almost same as that of declaring an
array of int, float or char etc.,
4/21/2021 1.5 _ Pointers Concepts 101

Array of Pointers
• Here ptr is an array of 5 integer pointers ie., the
integer pointers are ptr[0], ptr[1] ….ptr[4].
• Each element in this array can hold the address of
an integer variable.

Example

NULL Pointer
• Pointer is assigned a value NULL if it is not
assigned any valid address of the memory.
• NULL pointer is a pointer which points to
nothing.
• Pointer is initialized with a value NULL or 0
regardless of the pointer type.

Example

Uses of NULL pointer
• If no valid memory address is available to store it
in a pointer, initialize a pointer with NULL.
• If pointer is used in a function block, before
using it, check whether the pointer is not a NULL
value.
• Make a habit of initializing a pointer before
using it.
• Initialize a pointer with a valid address or NULL.

Example

Pointer to a Pointer
• C supports a pointer that points to another
pointer.
• This pointer in turn can point to another
pointer, and so on.
• At the simplest level, a pointer to a pointer is
declared in this manner:

• This pointer currently points nowhere. It can
be completely dereferenced after
– (i) pointing q to a pointer variable, say, p, and
– (ii) pointing p to another object, say, the simple
variable x.
• Thus, if p = &x and q = &p, then the value of x
can be evaluated using double indirection:

• This expression can be interpreted as *(*q),
which means using the dereferencing
operator twice.
• You need to use an extra * for every
additional level of indirection.
• Thus, you can create a pointer to q, say, r, and
then use ***r or **q or *p to evaluate x.

Example 1

Example 2

Uses and Caution of **P
• Why do we need pointer-to-pointers?
• Can a function that swaps two regular variables
be used to swap two pointers?
– No, it can’t because the function will swap the copies
of these pointers.
– The solution obviously lies in the use of pointer-to-
pointers as function arguments.
• double-indirection pointers are
– Implicitly used in handling 2D arrays.
– Explicitly used in applications that need to
manipulate pointer values inside a function.

Generic Pointer (or) void Pointer
• There is no data type associated with generic
pointer.
• It can be used to store address of any data
type and it can be converted to any type
using type casting.
• void pointers cannot be dereferenced.
• Generic pointer can be declared using the
keyword void.

Example

Dangling Pointer
• Even though the memory block is freed, it is still
accessible because the pointer to it is not lost
(dangling pointer).
• Dangling pointers arise during object destruction,
when an object that has an incoming reference is
deleted or deallocated, without modifying the value of
the pointer, so that the pointer still points to the
memory location of the deallocated memory.

Dangling Pointer
• Freeing a memory block with free(p) doesn’t
necessarily make it inaccessible because p continues
to point to the block. p is now a dangling pointer.
• As a safety measure, it should be set to NULL
immediately after invoking free.
• Because this memory—partially or totally—may have
already been allocated, a subsequent attempt to
access it using p could produce erroneous results or
even cause the program to crash.
• Setting p to NULL solves the problem easily.

Dangling Pointer
• A pointer pointing to a memory location that
has been deleted (or freed) is called dangling
pointer.
• There are three different ways where Pointer
acts as dangling pointer:
– De-allocation of memory
– Function Call
– Variable goes out of scope

Example – De-allocation of memory

Example – Function Call

Example – Function Call - Solution

Example – Variable goes out of scope

Wild Pointer
• A pointer which has not been initialized to
anything (not even NULL) is known as wild
pointer.
• The pointer may be initialized to a non-NULL
garbage value that may not be a valid address.

Thank you

Unit I : Contents
7. NULL pointers
9. Generic pointers
4/21/2021 127
1.6 _ Pointers and Strings

Pointers and Strings
• Strings are defined as arrays of characters.
• In order to allow variable length strings, the
string should be terminated by ‘0’ which is used
to indicate the end of a string.
• For example, the following program segment
declares a string s of 10 characters and assign the
starting address of string s into pointer ptr.
4/21/2021 1.6 _ Pointers and Strings 128

Pointers and Strings
• Three things will happen when we create the
below array.
– 10 memory locations are allocated for the array.
– The string “Hello” is stored in first 5 locations and in
the sixth location ‘0’ is automatically stored to
indicate the end of the string.
– The pointer ptr points at the first location of the
allocated memory

Example – program to use pointer to
print the string array

display the string using pointer with
“%s” as the formatting character

Example 2 - to count vowels and consonants in a string
using pointer

Example 3 - to find the length of the given string

create a list of strings
• When we want to create a list of strings, We
can use the following methods:
– Two dimensional character array
– Array of Pointers to Strings

Two dimensional character array
• The following program demonstrates the use of
2-D array to store the list of cities. It allocates
memory for storing 4 cities and for each city 10
locations are allocated.

Example 1

Example 2 - to sort the list of names in
alphabetical order

Array of Pointers to Strings
• When we want to store multiple strings, we
can create array of pointers and we can make
each pointer points to one string.
• Suppose there are N elements in an array, we
can make each element to point to one string.

• we have learned how we can use an array of
strings or 2-D array of characters.
• It may appear to you whenever you need to
store more than one string then an array of
strings is the way to go, unfortunately, this is
not the case.
• Consider the following example.

• As you can see not all strings are long enough to fill all
the rows of the array, that's why compiler fills these
empty spaces (highlighted using light grey color) with
the null characters ('0').
• The total size of the sports array is 75 bytes but
only 34 bytes is used, 41 bytes is wasted.
• 41 bytes may not appear much but in a large program,
a considerable amount of bytes would be wasted.
• What we need is a jagged array: A 2-D array whose
rows can be of different length.
• C doesn't provide jagged arrays but we can simulate
them using an array of pointer to a string.

• An array of pointers to strings is an array of
character pointers where each pointer points
to the first character of the string or the base
address of the string.
• Let's see how we can declare and initialize an
array of pointers to strings.

• Here sports is an array of pointers to strings.
• If initialization of an array is done at the time of
declaration then we can omit the size of an
array.
• So the above statement can also be written as:

• It is important to note that each element of
the sports array is a string literal and since a
string literal points to the base address of the
first character.
• The 0th element i.e arr[0] points to the base
address of string "golf".
• Similarly, the 1st element i.e arr[1] points to
the base address of string "hockey" and so on.

• Here is how an array of pointers to string is
stored in memory.

• 34 + 20 = 54.
• In this case, all string literals occupy 34 bytes
and 20 bytes are occupied by the array of
pointers i.e sports.
• So, just by creating an array of pointers to
string instead of array 2-D array of characters
we are saving 21 bytes (75-54=21) of memory

Example 1

Example 2 - Array of Pointers to Strings
• The following program demonstrates the use of
array of pointers to store the list of cities.
• Each pointer in the array can point to one city
name.
• It allocates memory for
– 1) storing the address of four strings
• ( 4 x 4 = 16 locations)
– 2) required memory locations
• (ie., Number of characters in the string + 1 location for
storing ‘0’ character) are allocated for each city.

Thank you

C Programming : Pointers and Arrays, Pointers and Strings

Recommended

More Related Content

What's hot (20)

Similar to C Programming : Pointers and Arrays, Pointers and Strings (20)

More from Selvaraj Seerangan (20)

Recently uploaded (20)

C Programming : Pointers and Arrays, Pointers and Strings