The document discusses pointers in C programming. It explains that pointers are variables that store memory addresses and can be used to manipulate other variables and arrays. The document covers declaring and initializing pointers, pointer arithmetic, using pointers to manipulate character arrays and strings, and two-dimensional arrays and pointers. Examples are provided to demonstrate various pointer operations and concepts.

1. Programming in C
Objectives
In this session, you will learn to:
Declare and manipulate pointers
Use pointers to manipulate character arrays
Ver. 1.0 Slide 1 of 29

2. Programming in C
Declaring and Manipulating Pointers
Every stored data item occupies one or more contiguous
memory cells.
Every cell in the memory has a unique address.
Any reference to a variable, declared in memory, accesses
the variable through the address of memory location.
Pointers are variables, which contain the addresses of other
variables (of any data type) in memory.
Ver. 1.0 Slide 2 of 29

3. Programming in C
Declaring Pointers
A pointer variable must be declared before use in a
program.
A pointer variable is declared preceded by an asterisk.
The declaration:
int *ptr; /* ptr is pointing to an int */
Indicates that ptr is a pointer to an integer variable.
An uninitialized pointer may potentially point to any area of
the memory and can cause a program to crash.
A pointer can be initialized as follows:
ptr= &x;
In the preceding initialization, the pointer ptr is pointing to x.
Ver. 1.0 Slide 3 of 29

4. Programming in C
Practice: 4.1
1. In the following declaration:
float *ptr_to_float;
The pointer variable ptr_to_float is pointing to a
variable of type ____________.
2. Is the following declaration valid?
*ptr_to_something;
3. State whether True or False:
An integer is declared In the following declaration:
int *ptr_to_int;
4. Is the following declaration valid?
int some_int, *ptr_to_int;
Ver. 1.0 Slide 4 of 29

5. Programming in C
Practice: 4.1 (Contd.)
Solution:
1. float
2. No. When a pointer variable is being declared, the type of
variable to which it is pointing to (int, float, or char)
should also be indicated.
3. False. A pointer to an integer is being declared and not an
integer.
4. Yes. It is okay to club declaration of a certain type along with
pointers to the same type.
Ver. 1.0 Slide 5 of 29

6. Programming in C
Manipulating Pointers
Pointers can be manipulated like variables.
The unary operator * gives value of the variable a pointer is
pointing to.
The unary operator * is also termed as the indirection
operator.
The indirection operator can be used only on pointers.
Ver. 1.0 Slide 6 of 29

7. Programming in C
Practice: 4.2
1. The symbol _________ is used to obtain the address of a
variable while the symbol__________ is used to obtain the
value of the variable to which a pointer is pointing to.
2. With the following declarations:
int x, y, *ptr;
Which of the following are meaningful assignments?
a. x = y;
b. y=*ptr;
c. x = ptr;
d. x = &.ptr;
e. ptr = &x;
f. x = &y;
Ver. 1.0 Slide 7 of 29

8. Programming in C
Practice: 4.2 (Contd.)
3. Consider the following sequence of statements and
complete the partially-filled table:
int x, y, *ptrl, *ptr2;
x = 65;
y = 89;
ptr1 = &x; /*ptrl points to x */
ptr2 = &y/; /* ptr2 points to y */
x = *ptr1; /* statement A*)
ptr1 = ptr2: /* statement B */
x = *ptr1; /* statement C*/
After statement &x x &y y ptr1 ptr2
A 1006 1018
B
C
Ver. 1.0 Slide 8 of 29

9. Programming in C
Practice: 4.2 (Contd.)
4. What is the output of the following sequence of statements:
int x, y, temp,*ptrl, *ptr2; /* declare */
x = 23;
y = 37;
ptrl = &x; /* ptrl points to x */
ptr2 = &y; /* ptr2 points to y */
temp = *ptrl;
*ptr1 = *ptr2;
*ptr2 = temp;
printf(“x is %d while y is %d”, x, y);
Ver. 1.0 Slide 9 of 29

10. Programming in C
Practice: 4.2 (Contd.)
Solution:
Microsoft Office
Word 97 - 2003 Document
Ver. 1.0 Slide 10 of 29

11. Programming in C
Pointer Arithmetic
Pointer Arithmetic:
Arithmetic operations can be performed on pointers.
Therefore, it is essential to declare a pointer as pointing to a
certain datatype so that when the pointer is incremented or
decremented, it moves by the appropriate number of bytes.
Consider the following statement:
ptr++;
It does not necessarily mean that ptr now points to the next
memory location. The memory location it will point to will
depend upon the datatype to which the pointer points.
– May be initialized when declared if done outside main().
– Consider the following example:
#include <stdio.h>
char movie[]= “Jurassic Park”;
main() {
char *ptr;
Ver. 1.0 Slide 11 of 29

12. Programming in C
Pointer Arithmetic (Contd.)
Consider the following example:
#include <stdio.h>
char movie[]= “Jurassic Park”;
main() {
char *ptr;
ptr=movie;
printf(“%s”, movie); /* output: Jurassic Park */
printf(“%s”,ptr); /* output: Jurassic Park */
ptr++;
printf(“%s”,movie); /* output: Jurassic Park */
printf(“%s",prr); /* output: urassic Park */
ptr++;
printf(“%s”,movie); /* output; Jurassic Park */
printf(“%s”,ptr); /* output: rassic Park */
/* Note that the incrementing of the pointer ptr
does not in any way affect the pointer movie */
}
Ver. 1.0 Slide 12 of 29

13. Programming in C
Practice: 4.3
1. Consider the following code snippet:
#include <stdio.h>
int one_d[] = {l,2,3};
main(){
int *ptr;
ptr = one_d;
ptr +=3; /* statement A*/
printf(“%dn”, *ptr); /*statement B */
}
– After statement A is executed, the new address of ptr will be
____ bytes more than the old address.
– State whether True or False:
The statement B will print 3.
Ver. 1.0 Slide 13 of 29

14. Programming in C
Practice: 4.3 (Contd.)
Solution:
– 12 ( Size of integer = 4*3)
– False. Note that ptr is now pointing past the one-d array. So,
whatever is stored (junk or some value) at this address is
printed out. Again, note the dangers of arbitrary assignments
to pointer variables.
Ver. 1.0 Slide 14 of 29

15. Programming in C
Using Pointers to Manipulate Character Arrays
Array name contains the address of the first element of the
array.
A pointer is a variable, which can store the address of another
variable.
It can be said that an array name is a pointer. Therefore, a
pointer can be used to manipulate an array.
Ver. 1.0 Slide 15 of 29

16. Programming in C
One-Dimensional Arrays and Pointers
One-Dimensional Arrays and Pointers:
Consider the following example:
#include <stdio.h>
char str[13]={“Jiggerypokry”};
char strl[]={ “Magic”};
main() {
char *ptr;
printf(“We are playing around with %s", str);
/* Output: We are playing around with Jiggerypokry*/
ptr=str ; /* ptr now points to whatever str is
pointing to */
printf(“We are playing around with %s" ,ptr);
/* Output: We are playing around with Jiggerypokry */
}
Ver. 1.0 Slide 16 of 29

17. Programming in C
One-Dimensional Arrays and Pointers (Contd.)
In the preceding example the statement:
ptr=str;
Gives the impression that the two pointers are equal. However,
there is a very subtle difference between str and ptr. str is a
static pointer, which means that the address contained in str
cannot be changed. While ptr is a dynamic pointer. The address
in ptr can be changed.
Ver. 1.0 Slide 17 of 29

18. Programming in C
Practice: 4.4
1. Given the declaration:
char some_string [10];
some_string points to _________.
2. State whether True or False:
In the following declaration, the pointer err_msg contains a
valid address:
char *err_msg = “Some error message”;
3. State whether True or False:
Consider the following declaration:
char *err_msg = “Some error message”;
It is more flexible than the following declaration:
char err_msg[19]=”Some error message”;
Ver. 1.0 Slide 18 of 29

19. Programming in C
Practice: 4.4 (Contd.)
Solution:
1. some_string [0]
2. True
3. True. Note that one does not have to count the size of the
error message in the first declaration.
Ver. 1.0 Slide 19 of 29

20. Programming in C
Two-Dimensional Arrays and Pointers
Two-dimensional arrays can be used to manipulate multiple
strings at a time.
String manipulation can also be done by using the array of
pointers, as shown in the following example:
char *things[6]; /* declaring an array of 6
pointers to char */
things[0]=”Raindrops on roses”;
things[1]=”And Whiskers on kettles”;
things[2]=”Bright copper kettles”;
things[3]=”And warm woolen mittens”;
things[4]=”Brown paper packages tied up with
strings”;
things[5]=”These are a few of my favorite
things”;
Ver. 1.0 Slide 20 of 29

21. Programming in C
Two-Dimensional Arrays and Pointers (Contd.)
The third line of the song can be printed by the following
statement:
printf(“%s”, things[2]);
/*Output: Bright copper kettles */
Ver. 1.0 Slide 21 of 29

22. Programming in C
Practice: 4.5
1. State whether True or False:
While declaring two-dimensional character arrays using
pointers, yon do not have to go through the tedium of
counting the number of characters in the longest string.
2. Given the following error messages:
All's well
File not found
No read permission for file
Insufficient memory
No write permission for file
Write a program to print all the error messages on screen,
using pointers to array.
Ver. 1.0 Slide 22 of 29

23. Programming in C
Practice: 4.5 (Contd.)
Solution:
1. True. New strings can be typed straight away within the {}. As
in:
char *err_msg_msg[]= {
“All's well”,
“File not found”,
“No read permission for file”,
“Insufficient memory”,
“No write permission for file”
};
The number of strings will define the size of the array.
Ver. 1.0 Slide 23 of 29

24. Programming in C
Practice: 4.5 (Contd.)
2. The program is:
# include<stdio.h>
# define ERRORS 5
char *err_msg[]= { /*Note the missing index*/
“All's well”,
“File not found”,
“No read permission for file”,
“Insufficient memory”,
“No write permission for file” };
main() {
int err_no;
for ( err_no = 0; err_no < ERRORS; err_no++ ) {
printf ( “nError message %d is : %sn”, err_no +
1, err_msg[err_no]); } }
Ver. 1.0 Slide 24 of 29

25. Programming in C
Two-Dimensional Arrays and Pointers (Contd.)
Consider the following two-d array declaration:
int num[3][4]= {
{3, 6, 9, 12},
{15, 25, 30, 35},
{66, 77, 88, 99}
};
This statement actually declares an array of 3 pointers (constant)
num[0], num[l], and num[2] each containing the address of
the first element of three single-dimensional arrays.
The name of the array, num, contains the address of the first
element of the array of pointers (the address of num[0]).
Here,
*num is equal to num[0] because num[0] points to num[0][0].
*(*num) will give the value 3.
*num is equal to num[0].
Ver. 1.0 Slide 25 of 29

26. Programming in C
String-Handling Functions Using Pointers
Pointers can be used to write string-handling functions.
Consider the following examples:
/* function to calculate length of a string*/
#include <stdio.h>
main() {
char *ptr, str[20];
int size=0;
printf(“nEnter string:”);
gets(str);
fflush(stdin);
for(ptr=str ; *ptr != '0'; ptr++) {
size++;
} printf(“String length is %d”, size);
}
Ver. 1.0 Slide 26 of 29

27. Programming in C
Using Pointers to Manipulate Character Arrays (Contd.)
/*function to check for a palindrome */
# include <stdio.h>
main() {
char str[50],*ptr,*lptr;
printf(“nEnter string :”);
gets(str); fflush(stdin);
for(lptr=str; *lptr !=’0'; lptr++); /*reach
the string terminator */
lptr--; /*position on the last character */
for(ptr=str; ptr<=lptr; lptr--,ptr++) {
if(*ptr != *lptr)
break;}
if(ptr>lptr)
printf(“%s is a palindrome” );
else
printf(“%s is not a palindrome");
}
Ver. 1.0 Slide 27 of 29

28. Programming in C
Summary
In this session, you learned that:
A pointer is a variable, which contains the address of some
other variable in memory.
A pointer may point to a variable of any data type.
A pointer can point to any portion of the memory.
A pointer variable is declared as:
datatype *<pointer variable name>
A pointer variable is initialized as:
pointer variable name> = &<variable name to which
the pointer will point to>
– The & returns the address of the variable.
– The * before a pointer name gives the value of the variable to
which it is pointing.
Ver. 1.0 Slide 28 of 29

29. Programming in C
Summary (Contd.)
Pointers can also be subjected to arithmetic.
Incrementing a pointer by 1 makes it point to a memory
location given by the formula:
New address = Old address + Scaling factor
One-dimensional character arrays can be declared by
declaring a pointer and initializing it.
The name of a character array is actually a pointer to the first
element of the array.
Two-dimensional character arrays can also be declared by
using pointers.
Ver. 1.0 Slide 29 of 29