The document discusses recursion and pointers in C programming. It provides examples of using recursion to calculate factorials and print a series of numbers. Recursion involves defining a base case and dividing a problem into sub-problems that are similar to the original problem. Pointers store memory addresses and can be used to pass arguments by reference. The address operator & returns the memory address of a variable, while the indirection operator * accesses the value at a pointer's address. Pointers allow returning multiple values from functions and are important for advanced data structures.

1. Computing Fundamentals
Dr. Muhammad Yousaf Hamza
Deputy Chief Engineer, PIEAS

2. Recursion
Dr. Yousaf, PIEAS

3. Recursion
Example: factorials
– 5! = 5 * 4 * 3 * 2 * 1
– Notice that
• 5! = 5 * 4!
• 4! = 4 * 3! ...
– Can compute factorials recursively
– Solve base case (1! = 0! = 1) then plug in
• 2! = 2 * 1! = 2 * 1 = 2;
• 3! = 3 * 2! = 3 * 2 = 6;
Write a recursive function int fact(int num) that should return
the factorial of given number num
Dr. Yousaf, PIEAS

4. Dr. Yousaf, PIEAS
//Calculate Factorial using Recursion
# include<stdio.h>
int factorial(int num);
int main ()
{
int f,x;
printf("Enter integer value in the range 1
to 10: ");
scanf("%d", &x);
if (x > 10 || x < 1)
printf ("Illegal input!n");
else
{
f = factorial(x);
printf ("%d factorial equals %dn", x,f);
}
getchar(); return 0; }
int factorial (int a)
{
if (a==1) // base case
return 1;
else
{
a *= factorial(a-1);
return a;
}
}

5. Recursion
• Recursive functions
• A function that calls itself inside its body is called a
recursive function
• Can only solve a base case
– Divide a problem into
• What it can do
• What it cannot do
– What it cannot do resembles original problem
– The function launches a new copy of itself (recursion
step) to solve what it cannot do
– Eventually base case gets solved
• Gets plugged in, works its way up and solves whole problem
Dr. Yousaf, PIEAS

6. Example Using Recursion
/*This function prints all the number between zero and a given number that is
greater than zero. */
#include <stdio.h>
void printSeries(int num);
int main()
{
printSeries(6);
getchar(); return 0;
}
void printSeries(int num)
{
if(num<=0)
return;
printf("%d", num);
printSeries(num-1);
}
Dr. Yousaf, PIEAS

7. Example Using Recursion
/*This function prints all the number between zero and a given number that is
greater than zero. */
#include <stdio.h>
void printSeries(int num);
int main()
{
printSeries(6);
getchar(); return 0;
}
void printSeries(int num)
{
if(num<=0)
return;
printf("%d", num);
printSeries(num-1);
}
Dr. Yousaf, PIEAS

8. Example Using Recursion:
The Fibonacci Series
• Fibonacci series: 0, 1, 1, 2, 3, 5, 8, 13, ...
– Each number is the sum of the previous two
– fib( n ) = fib( n - 1 ) + fib( n – 2 )
– Write a recursive function that can print first N terms of
Fibonacci series ,
– Can be solved recursively:
Code for the fibaonacci function
int fibonacci(int n )
{
if (n == 0 || n == 1) // base case
return n;
else
return fibonacci(n - 1)+ fibonacci(n – 2);
}
Dr. Yousaf, PIEAS

9. Example Using Recursion:
The Fibonacci Series
• Set of recursive calls to function fibonacci
f( 3 )
f( 1 )f( 2 )
f( 1 ) f( 0 ) return 1
return 1 return 0
return +
+return
Dr. Yousaf, PIEAS

10. Dr. Yousaf, PIEAS
// To generate Fibonacci series
using Recursion
#include<stdio.h>
int fibonacci(int n);
int main()
{
int i, terms, result;
printf("Please enter the number of
terms from 1 to 20: ");
scanf("%d",&terms);
for ( i = 0; i<= terms; i++)
{
result = fibonacci(i);
printf("%d, ", result);
}
getchar(); return 0; }
// Function Definition
int fibonacci(int n)
{
if ( n == 0 || n == 1 )
return n;
else
return fibonacci( n - 1 ) +
fibonacci( n - 2 );
}

11. Recursion vs. Iteration
• Repetition
– Iteration: explicit loop
– Recursion: repeated function calls
• Termination
– Iteration: loop condition fails
– Recursion: base case recognized
Dr. Yousaf, PIEAS

12. POINTERS
Dr. Yousaf, PIEAS

13. /* Demonstration on Pointers
A very simple program to print a value of a variable
without using pointer */
#include<stdio.h>
int main()
{
int x = 20;
printf("n x = %d", x);
getchar();
return 0;
}
Dr. Yousaf, PIEAS

14. // A very simple program to print the address and value of
a variable using pointer
#include<stdio.h>
int main()
{
int x = 20;
int *ptrx; //Pointer is declared. Select any name instead of ptrx.
ptrx = &x; // Initialization of the pointer
printf("n address of x = %d", ptrx);
// It would print the address value
printf("n Value of x = %d",*ptrx);
/* It would print the value of the variable stored at the
address value of the pointer */
getchar(); return 0;
}
Dr. Yousaf, PIEAS

15. Dr. Yousaf, PIEAS

16. • Pointers are powerful and very useful tools
• With pointers we can effectively return more than one
value from a function
• Arrays are a form of pointer REALLY
• Pass by reference is also possible
Dr. Yousaf, PIEAS
The Importance of Pointers

17. The Importance of Pointers
• Pointers can be used for advanced data structures.
• Pointers can be "cheaper" to pass around a
program.
• You could program without using them but you
would be making life more difficult for yourself.
• Some things simply can't be done sensibly in C
without them.
Dr. Yousaf, PIEAS

18. What are pointers?
• Pointers are considered as one of the most
difficult topics to understand in C.
• Pointers "point at" areas of your computer's
memory (address of the memory)
• int *p; says p is a pointer to an int
• Imagine your computer's memory as a series of
boxes which all hold ints
56 71 12 3 21 7
p points at one of the ints
Dr. Yousaf, PIEAS

19. & means "address of" or "point at
me"
* means value or "what am I
pointing at?"
int *p; // p is a pointer to an int
int q= 5; // q is an int
p= &q; // p now points at q
printf (“The value stored at p location is
%dn",*p); // 5
/*We use *p to mean "the value in the memory where pointer p is pointing
at*/
q=5
p
Dr. Yousaf, PIEAS

20. & means "address of" or "point at
me"
* means value or "what am I
pointing at?"
int *p; // p is a pointer to an int
int q= 5; // q is an int
p= &q; // p now points at q
printf (“The value stored at p location is
%dn",*p); // 5
*p= 9;
printf (“%dn",q); // 9
printf (“The value stored at p location is
%dn",*p); // 9
Dr. Yousaf, PIEAS

21. p= &q; // p now points at q
This is what was going on when we use & in scanf
int x;
scanf(“%d”, &x);
Dr. Yousaf, PIEAS
& means "address of" or "point at

22. Pointer Variable Declarations and
Initialization
• Pointer variables
– Normal variables contain a specific value (direct reference)
– int count = 7;
– Pointer contains address of a variable that has a specific value
(indirect reference)
– Indirection – referencing a pointer value
– int *countPtr
– countPtr = &count
count
7
count
7
countPtr
Dr. Yousaf, PIEAS

23. Pointer Variable Declarations and
Initialization
• Pointer declarations
– * used with pointer variables
int *myPtr;
– Declares a pointer to an int (pointer of type int *)
– Multiple pointers require using a * before each variable
declaration
int *myPtr1, *myPtr2;
– Can declare pointers to any data type
Dr. Yousaf, PIEAS

24. Pointer Variables
• Pointer variables are variables that store memory
addresses.
• Pointer Declaration:
– int x, y = 5;
– int *ptr;
– /*ptr is a POINTER to an integer variable*/
• Reference operator &:
– ptr = &y;
– /*assign ptr to the MEMORY ADDRESS of y.*/
• Dereference operator *:
– x = *ptr;
– /*assign x to the int that is pointed to by ptr */
Dr. Yousaf, PIEAS

25. Pointer Variables
int x;
int y = 5;
int *ptry;
ptr = &y;
x = *ptry;
printf(“%d”, x); //5 ptry
Dr. Yousaf, PIEAS

26. Pointer Variables
Dr. Yousaf, PIEAS

27. #include<stdio.h>
int main()
{
int x = 9;
int *ptrx = 0;
ptrx = &x;
printf("address of x = %dn",ptrx);
printf("Value in ptrx is %d", *ptrx);
getchar();
return 0;
}
Dr. Yousaf, PIEAS

28. Dr. Yousaf, PIEAS

29. #include<stdio.h>
int main()
{
double x = 7.8;
double *ptrx = 0;
ptrx = &x;
printf("address of x = %dn",ptrx);
printf("Value in ptrx is %lf", *ptrx);
getchar();
return 0;
}
Dr. Yousaf, PIEAS

30. Dr. Yousaf, PIEAS

31. Pointer Operators
• & (address operator)
– Returns address of operand
int y = 5;
int *yPtr;
yPtr = &y; // yPtr gets address of y
yPtr “points to” y
yPtr
y
5
yptr
500000 600000
y
600000 5
Address of y
is value of
yptr
Dr. Yousaf, PIEAS

32. Pointer Operators
• * (indirection/dereferencing operator)
– Returns a synonym/alias of what its operand points to
– *yptr returns y (because yptr points to y)
– * can be used for assignment
• Returns alias to an object
int y = 5;
int *yPtr;
yPtr = &y;
*yptr = 7; // changes y to 7
Dr. Yousaf, PIEAS

33. Revision
• We declare a pointer with a *
• We use an & to get the "address of" and save this
address in a pointer variable
• We use a * to get the value "pointed at“
int *p;
int q = 5;
printf ("q is %dn",q); // 5
p= &q;
printf (“%dn",*p); //5
*p= 6;
printf ("q is now %dn",q); // 6
printf (“%dn",*p); //6
Dr. Yousaf, PIEAS