Pointers allow programs to store and manipulate memory addresses in C. A pointer is a variable that contains the address of another variable. Pointers can be used to access array elements, pass arguments by reference, and dynamically allocate memory on the heap. There are different types of pointers like void pointers, constant pointers, and pointers to functions. Pointer arithmetic and pointer declarations are also discussed in the document.

1. Pointers

2. Introduction to pointers

Pointer is Special Variable used to
Reference and de-reference memory.

When we declare integer pointer then we
can only store address of integer variable
into that pointer.

Similarly if we declare character pointer
then only the address of character
variable is stored into the pointer
variable.

3. #include<stdio.h>
int main()
{
int a = 3;
int *ptr,**pptr;
ptr = &a;
pptr = &ptr;
return(0);
}

4. Memory required to store Pointer

Pointer Variable Stores the address of
the variable.

Variable may be integer , character ,
float but the address of the variable is
always integer so Pointer requires 4
bytes of memory.

5. Declaring Pointer Variables
int n = 20;
int *ptr;
char ch = 'A';
char *cptr;
float fvar = 3.14;
float *fptr;

6. ●
int *x;
●
int **y;
●
double *z;
x some int
some *int some int
some double
y
z

7. Applications of Pointers

Passing Parameter by Reference

Accessing Array element

Dynamic Memory Allocation

Reducing size of parameter

8. Passing parameters by reference
void interchange(int *num1,int *num2)
{
int temp;
temp = *num1;
*num1 = *num2;
*num2 = temp;
}

9. Accessing array elements
int main(){
int a[5] = {1,2,3,4,5};
int *ptr;
ptr = a; //storing base address of array in pointer.
//accessing each and individual location using pointer.
for(i=0;i<5;i++) {
printf("%d",*(ptr+i));
}
return(0);
}

10. Dynamic memory allocation
We can use pointer to allocate memory dynamically. Malloc and calloc
function is used to allocate memory dynamically.
#include <stdio.h>
#include <stdlib.h>
int main(){
char *str;
str = (char *) malloc(15);
strcpy(str, "mahesh");
printf("String = %s, Address = %un", str, str);
free(str);
return(0);
}

11. Operations on Pointers
●
Can be done, Valid Operations
– Addition/Subtraction of a number to/from pointer
– Subtraction of two pointers
– Comparison of two pointers
– Assignment of a pointer to another pointer
●
Can NOT be done, Invalid Operations
– Addition of two pointers
– Multiplication/Division of a pointer with a number

12. Pointer arithmetic
●
Integer math operations can be used with pointers.
●
If you increment a pointer, it will be increased by the size
of whatever it points to.
●
You can use the integer x points to in a C expression
like this:
y = *x + 17;
*x = *x +1;

13. Void Pointers

In C General Purpose Pointer is called as void
Pointer.

It does not have any data type associated with
it.

It can store address of any type of variable.

The compiler has no idea what type of object
a void Pointer really points to.

14. Void Pointer Example
void *ptr; // ptr is declared as Void pointer
char cnum;
int inum;
float fnum;
ptr = &cnum; // ptr has address of character data
ptr = &inum; // ptr has address of integer data
ptr = &fnum; // ptr has address of float data

15. Dereferencing Void Pointers
Type of Address Stored
in Void Pointer
Dereferencing Void Pointer
Integer *((int*)ptr)
Character *((char*)ptr)
Floating *((float*)ptr)

16. #include<stdio.h>
int main() {
int inum = 8;
float fnum = 67.7;
void *ptr;
ptr = &inum;
printf("nThe value of inum = %d",*((int*)ptr));
ptr = &fnum;
printf("nThe value of fnum = %f",*((float*)ptr));
return(0);
}

17. Double Pointer
Pointer to Pointer in C Programming.
int num = 45 , *ptr , **ptr2ptr ;
ptr = &num;
ptr2ptr = &ptr;

18. Pointer to Constant Objects
●
Pointer to a Constant Object is called as ‘Pointer to
Constant Object’.
int n = 30 ;
const int ptr;
ptr = &n;
●
“const int” means integer is constant.
●
We cannot change value of the integer.
●
We can change address of such pointer so that it
will point to new memory location.

19. Constant Pointers
●
As name suggests , Constant Pointers Cannot be
modified .
●
Modification in Integer to which it Points to is
Allowed.
int num = 20;
int * const ptr = &num ; // Declare Constant
pointer
*ptr = 20 ; // Valid Statement
ptr ++ ; // Invalid Statement

20. No Pointer to constant Constant Pointers
1 *ptr = 20 Statement is Invalid in
Pointer to Constant i.e Assigning Value
is Illegal
*ptr = 20 is Absolutely Valid in
Constant Pointers i.e Assigning Value
is Perfectly legal
2 ptr ++ Statement is Valid in Pointer to
Constant
ptr ++ Statement is invalid in
Constant Pointers
3 Pointer Can be Incremented and
Decremented
Pointer Cannot be Incremented and
Decremented
4 Pointer is Pointing to Constant Data
Object
Constant Pointer is Pointing to Data
Objects
5 Declaration : const int *ptr ; Declaration : int * const ptr ;

21. Functions

22. Introduction to Function

Block of statements that perform the particular
task.

Enables modular programming.

Has pre defined prototype.

Same function can be accessed from different
places within a program.

Once a function execution is completed , control
return to the place from where the function was
called.

23. Advantages

Modular Programming

Length of source program can be reduced
Easy to locate and isolate faulty function
Functions can be used by other program’s

24. Types of Functions
Library (Built In) Functions:
They are written in the header files.
To use them appropriate header files should be included.
User Defined Functions
Written by the user at the time of programming.

25. Elements of User defined functions
Function Prototype
Function Call
Function arguments and parameters
Function Definitions

26. Function prototype
It specify the type of value that is to be return from
the function and that is to be passed to the function.
It is defined in the beginning before the function
call is made.
Syntax:
return-type name-of-function(list of arguments);
Example
Void sum(int, int);

27. Function Call
A function can be called by specifying name and
list of arguments enclosed in parenthesis and
separated by comma.
If there is no arguments empty parenthesis are place
after function name.
If function return a value, function call is written as
assignment statement as:
A=sum(x,y);

28. Function arguments and parameters
Arguments are also called actual parameters.
Arguments are written within parenthesis at the
time of function call.
Parameters are also called formal parameters.
These are written within parenthesis at the time of
function definition.

29. Function Definition
It is the independent program module.
It is written to specify the particular task that
is to be performed by the function.
The first line of the function is called function
declarator and rest line inside { } is called
function body.

30. ●

31. Categories of function

Function with no arguments and no return

Function with arguments but no return

Function with no arguments and return

Function with arguments and return

32. Function with no argument and no return
●

33. Function with argument and no return

34. Function with no argument and return

35. Function with argument and return

36. Methods of calling function
●
Call by value
●
Call by reference

37. Call by value

Copies the value of actual parameters into
formal parameters.

During execution whatever changes are made
in the formal parameters are not reflected
back in the actual parameters.

39. Call by Reference

Reference(address) of the original variable is
passed.

Function does not create its own copy, it
refers to the original values by reference.

Functions works with the original data and
changes are made in the original data.

41. Function Pointers
●
A pointer which keeps address of a function is
known as function pointer.
●
int (*f)()
●
This is a pointer to a function. The name of the
pointer is 'f'. But the function it points to could be
any function that takes no parameters and returns
an int.

42. Example
#include<stdio.h>
void display();
int main() {
void (*ptr)();
ptr = display;
(*ptr)();
return(0);
}
void display(){
printf("Hello World");
}

43. Addition of 2 numbers using function pointers
#include<stdio.h>
int sum (int n1,int n2);
int main() {
int num1 = 10;
int num2 = 20;
int result;
int (*ptr)(int,int);
ptr = sum;
result = (*ptr)(num1,num2);
printf("Addition : %d",result);
return(0);
}
int sum (int n1,int n2){
return(n1 + n2);
}

44. Accessing Integer using Character
#include<stdio.h>
int main() {
int a=320;
char *ptr;
ptr=(char *)&a;
printf("%d",*ptr);
return(0);
}

45. Array of function pointers
An array of function pointers can be created
for the functions of same return type and
taking same type and same number of
arguments.

46. Example1
#include<stdio.h>
void fun1()
{
printf("hai");
}
void fun2()
{
printf("hello");
}
void fun3()
{
printf("bye");
}

47. void (*func_ptr[3])()= {fun1, fun2, fun3};
int main()
{
int i;
scanf("%d",&i);
if((i>=0)&&(i<=2))
{
(*func_ptr[i])();
}
return 0;
}

48. Example2
#include <stdio.h>
int getSum(int, int);
int getDifference(int, int);
int getProduct(int, int);
int getDivision(int, int);
int (*functionptr[4])(int, int) = {getSum, getDifference, getProduct, getDivision};
int main()
{
int a = 50, b = 20;
printf("Sum of %d and %d : %dn", a, b,(*functionptr[0])(a, b));
printf("Difference of %d and %d : %dn", a, b,(*functionptr[1])(a, b));
printf("Product of %d and %d : %dn", a, b,(*functionptr[2])(a, b));
printf("Division of %d and %d : %dn", a, b,(*functionptr[3])(a, b));
}

49. int getSum(int x, int y)
{
return x + y;
}
int getDifference(int x, int y)
{
return x - y;
}
int getProduct(int x, int y)
{
return x * y;
}
int getDivision(int x, int y)
{
return x / y;
}

50. Pointers to Structures
Pointers can be accessed along with structures.
struct name
{
int a;
float b;
.
.
};
-------- Inside function -------
struct name *ptr;

51. The accessing of these structure members are given
by
(*ptr).a
(*ptr).b
Structure pointer member can also be accessed
using -> operator.
(*ptr).a is same as ptr->a.
(*ptr).b is same as ptr->b.

52. Example
#include <stdio.h>
struct foo {
int a, b, c;
};
void inp(struct foo *);
void outp(struct foo);
void main( ) {
struct foo x;// declare x to be a foo
inp(&x); // get its input, passing a pointer to foo
outp(x); // send x to outp, this requires 2 copying actions
}
void inp(struct foo *x)
{
scanf("%d%d%d", &x->a, &x->b, &x->c);
}
void outp(struct foo x) {
printf("%d %d %dn", x.a, x.b, x.c);
}

53. Linked Structures
These are dynamic structures, when you want to
add a node, you allocate a new chunk of memory
and attach it to the proper place in the structure via
the pointers.
Each node in the structure will have at least one
datum and at least one pointer.
In linked lists, the pointer is a next pointer to the
next node in the list, in a tree, there are left and
right children pointers.

54. Declarations for Nodes
struct node {
int data;
struct node *next;
};
node *front;
front is a pointer to the first node in a linked list. It may
initially be NULL. Traversing our linked list might use
code like this:
temp = front;
while(temp!=NULL)
{
// process temp
temp=temp->next;
}

55. Command line arguments

Command line arguments are a way of providing
input to a program.

Many real-world unix programs use command line
arguments rather than printf/scanf to get their
input.

The user of the program types the input to the
program after the name of the program on the
command line.

56. 
main() function of a C program accepts arguments
from command line by following commands. They
are,
argc
argv[]
int main(int argc, char *argv[])

argc is a variable that indicates the number of
things on the command line.

argv is an array of the arguments.

57. 
when we compile a program (test.c), we get executable file with
the name “test”.

Now, we run the executable “test” along with 4 arguments in
command line like,
./test this is a program
Where,
argc = 5
argv[0] = “test”
argv[1] = “this”
argv[2] = “is”
argv[3] = “a”
argv[4] = “program”
argv[5] = NULL

58. Conventional rules:
 Arguments are always passed to main( ).
 There must be two
first is an integer
second char pointer to an array
 First argument (argv[0]) will always be the name of the
calling program.
 argc will always be at least 1
 The first argument is always argv[0]
 The last argument is always argv[argc-1]
 argv[argc] will always be a null pointer
 Arguments are always passed as character strings.
Numbers must be converted from characters to integers,
floats, doubles, etc.

59. Example1
#include<stdio.h>
int main(int argc,char *argv[])
{
int i;
for(i=1;i<argc;i++)
{
printf(“%s”,argv[i]);
}
return 0;
}

60. Example2
#include<stdio.h>
#include<stdlib.h>
int main(int argc,char *argv[])
{
int i;
for(i=1;i<argc;i++)
{
printf(“%d”,atoi(argv[i]));
}
return 0;
}

61. Arrays with negative indexes
| a | b | c | d | e | f | g |
^------------ arr[3]
^----------------arr[2]
^------------------ arr[1]
^---------------------- arr[0]
^------------------------- arr[-1]
^------------------------------ arr[-2]
^---------------------------------- arr[-3]

62. int arr[10];
int x = arr[-2]; // invalid; out of range
●
Arrays with negative indices is possible when
a pointer points to the elements of an array.
int arr[10];
int* p = &arr[2];
int x = p[-2]; // valid: accesses arr[0]

63. Example
#include <stdio.h>
int main(void)
{
char a[] = "pascual";
char *p = a;
p += 3;
printf("%cn", p[-1]); /* -1 is valid here? */
return 0;
}