Functions

1. Functions • a group of declarations and statements that is assigned a name • effectively, a named statement block • usually has a value • a sub-program • when we write our program we always define a function named main • inside main we can call other functions • which can themselves use other functions, and so on…

2. Example - Square #include <stdio.h> double square(double a) { return a*a; } int main(void) { double num; printf("enter a number\n"); scanf("%lf",&num); printf("square of %g is %g\n",num,square(num)); return 0; } This is a function defined outside main Here is where we call the function square

3. Why use functions? • they can break your problem down into smaller sub-tasks • easier to solve complex problems • they make a program much easier to read and maintain • abstraction – we don’t have to know how a function is implemented to use it • generalize a repeated set of instructions • we don’t have to keep writing the same thing over and over

4. Characteristics of Functions return-type name(arg_type1arg_name1, arg_type2 arg_name2, …) { function body; return value; } int main(void) { … } double square(double a) { return a*a; }

5. Return Statement • Return causes the execution of the function to terminate and usually returns a value to the calling function • The type of the value returned must be the same as the return-type defined for the function (or a ‘lower’ type) • If no value is to be returned, the return-type of the function should be set to ‘void’

6. Factorials galore int main(void) { int num; printf("enter a number\n"); scanf("%d",&num); printf("%d!=%d\n",num,factorial(num)); return 0; } #include <stdio.h> int factorial(int n) { int i, fact = 1; for (i=2; i<=n; i++) fact *= i; return fact; }

7. A Detailed Example Write a program that receives a nominator and a denominator from the user, and displays the reduced form of the number. For example, if the input is 6 and 9, the program should display 2/3.

8. Example – solution (step I) #include <stdio.h> int main(void) { int n, d; printf("Please enter nominator and denominator: "); scanf("%d%d", &n, &d); Calculate n’s and d’s Greatest Common Divisor printf("The reduced form of %d/%d is %d/%d", n, d, n/gcd, d/gcd); return 0; }

9. Example – solution (step II) #include <stdio.h> int main(void) { int n, d, g; printf("Please enter nominator and denominator: "); scanf("%d%d", &n, &d); g = gcd(n, d); printf("The reduced form of %d/%d is %d/%d", n, d, n/g, d/g); return 0; }

10. Example – solution (step III) /* Returns the greatest common divisor of its two parameters. Assumes both are positive. The function uses the fact that the if r = mod(y, x) then the gcd of y and x equals the gcd of x and r. */ int gcd(int x, int y) { int tmp; while(x > 0) { tmp = x; x = y % x; y = tmp; } return y; }

11. GCD – step by step int main(void) { int n, d, g; printf("Please enter … : "); scanf("%d%d", &n, &d); g = gcd(n, d); printf("The reduced form…", n, d, n/g, d/g); return 0; } n d g 6 9 ---

12. GCD – step by step int main(void) { int n, d, g; printf("Please enter … : "); scanf("%d%d", &n, &d); g = gcd(n, d); printf("The reduced form…", n, d, n/g, d/g); return 0; } n d g 6 9 ---

13. GCD – step by step int gcd(int x, int y) { int tmp; while(x > 0) { tmp = x; x = y % x; y = tmp; } return y; } x y tmp 6 9 ---

14. GCD – step by step int gcd(int x, int y) { int tmp; while(x > 0) { tmp = x; x = y % x; y = tmp; } return y; } x y tmp 6 9 ---

15. GCD – step by step int gcd(int x, int y) { int tmp; while(x > 0) { tmp = x; x = y % x; y = tmp; } return y; } x y tmp 6 9 6

16. GCD – step by step int gcd(int x, int y) { int tmp; while(x > 0) { tmp = x; x = y % x; y = tmp; } return y; } x y tmp 3 9 6

17. GCD – step by step int gcd(int x, int y) { int tmp; while(x > 0) { tmp = x; x = y % x; y = tmp; } return y; } x y tmp 3 6 6

18. GCD – step by step int gcd(int x, int y) { int tmp; while(x > 0) { tmp = x; x = y % x; y = tmp; } return y; } x y tmp 3 6 6

19. GCD – step by step int gcd(int x, int y) { int tmp; while(x > 0) { tmp = x; x = y % x; y = tmp; } return y; } x y tmp 3 6 3

20. GCD – step by step int gcd(int x, int y) { int tmp; while(x > 0) { tmp = x; x = y % x; y = tmp; } return y; } x y tmp 0 6 3

21. GCD – step by step int gcd(int x, int y) { int tmp; while(x > 0) { tmp = x; x = y % x; y = tmp; } return y; } x y tmp 0 3 3

22. GCD – step by step int gcd(int x, int y) { int tmp; while(x > 0) { tmp = x; x = y % x; y = tmp; } return y; } x y tmp 0 3 3

23. GCD – step by step int gcd(int x, int y) { int tmp; while(x > 0) { tmp = x; x = y % x; y = tmp; } return y; } x y tmp 0 3 3

24. GCD – step by step int main(void) { int n, d, g; printf("Please enter … : "); scanf("%d%d", &n, &d); g = gcd(n, d); printf("The reduced form…", n, d, n/g, d/g); return 0; } n d g 6 9 3

25. Example – Complete Solution gcd.c

26. Exercise • Input – • An integer n • Output – • The n’th fibonacci number • Note – • Use an appropriately defined function

27. Solution fibonacci_func.c

28. Exercise Write a program that gets a positive integer from the user and prints all the prime numbers from 2 up to that integer. (Use a function that returns 1 if its parameter is prime, 0 otherwise)

29. Solution is_prime_func.c

30. Exercise • Newton was the first to notice that for any positive n, and when x0=1, the following series converges to sqrt(n) – • Use this fact to write a program that accepts a positive number and outputs its square root • Hint – the thousandth element of Newton’s series is a good-enough approximation

31. Solution sqrt.c

32. The Great Void • Sometimes there’s no reason for a function to return a value • In these cases, the function return type should be ‘void’ • If the ‘return’ keyword is used within such a function it exits the function immediately. No value needs be specified • Calling ‘return’ in a function returning void is not obligatory • If the function receives no parameters, the parameter list should be replaced by ‘void’

33. Example void ShowHelp(void) { printf("This function explains what this program does…\n"); printf("Yadayadayada"); /* …. */ } int main(void) { char choice; printf("Please enter your selection: "); scanf("%c", &choice); if (choice==‘h’) ShowHelp(); else if /* Program continues … */ }

34. Pass-by-value • Function arguments are passed to the function by copying their values rather than giving the function direct access to the actual variables • A change to the value of an argument in a function body will not change the value of variables in the calling function • Example – add_one.c

35. add_one – step by step int add_one(int b) { b=b+1; return b; } int main(void) { int a=34,b=1; a=add_one(b); printf("a = %d, b = %d\n", a, b); return 0; } Main() memory state a b 34 1

36. add_one – step by step int add_one(int b) { b=b+1; return b; } int main(void) { int a=34,b=1; a=add_one(b); printf("a = %d, b = %d\n", a, b); return 0; } Main() memory state a b 34 1

37. add_one – step by step int add_one(int b) { b=b+1; return b; } int main(void) { int a=34,b=1; a=add_one(b); printf("a = %d, b = %d\n", a, b); return 0; } Main() memory state a b 34 1 add_one memory state b 1

38. add_one – step by step int add_one(int b) { b=b+1; return b; } int main(void) { int a=34,b=1; a=add_one(b); printf("a = %d, b = %d\n", a, b); return 0; } Main() memory state a b 34 1 add_one memory state b 2

39. add_one – step by step int add_one(int b) { b=b+1; return b; } int main(void) { int a=34,b=1; a=add_one(b); printf("a = %d, b = %d\n", a, b); return 0; } Main() memory state a b 34 1 add_one memory state b 2

40. add_one – step by step int add_one(int b) { b=b+1; return b; } int main(void) { int a=34,b=1; a=add_one(b); printf("a = %d, b = %d\n", a, b); return 0; } Main() memory state a b 2 1

41. add_one – step by step int add_one(int b) { b=b+1; return b; } int main(void) { int a=34,b=1; a=add_one(b); printf("a = %d, b = %d\n", a, b); return 0; } Main() memory state a b 2 1

42. Riddle me this int main(void) { int n; printf("enter a number\n"); scanf("%d",&n); printf("%d!=%d\n", n, factorial(n)); /* What will this print? */ printf("n = %d\n", n); return 0; } #include <stdio.h> int factorial(int n) { int fact = 1; while (n>1) { fact *= n; n--; } return fact; }

43. Scope of variables • A variable declared within a function is unrelated to variables declared elsewhere, even if they have the same name • A function cannot access variables that are declared in other functions • Example – scope.c

44. Wrong way to do it int add_one(int b) { a=b+1; } int main(void) { int a=34,b=1; add_one(b); printf("a = %d, b = %d\n", a, b); return 0; }

45. Function Declaration • Most software projects in C are composed of more than one file • We want to be able to define the function in one file, and to use it in all files • For this reason, the function must be declared in every file in which it’s called, before it’s called for the first time • the declaration contains: • the function name • the data types of the arguments (their names are optional) • the data type of the return value

46. Function Declaration #include <stdio.h> int factorial(int a); /* Function Declaration! */ int main(void){ int num; printf("enter a number\n"); scanf("%d",&num); printf("%d!=%d\n",num,factorial(num)); return 0; } int factorial(int a){ int i,b=1; for(i=1; i<=a; i++) b=b*i; return b; }

47. Function Declaration • stdio.h actually contains a large set of function declarations • The #include directive tells the compiler to insert these declarations into the file, so that these functions could be called

48. The math library • A collection of mathematical functions • Need to include the header file math.h (#include <math.h>) • Use functions of the library, e.g. double s,p; s=sqrt(p); • Declared in math.h : double sqrt ( double x );

49. The math library • sin(x), cos(x), tan(x) • x is given in radians • asin(x), acos(x), atan(x) • log(x) • sqrt(x) • pow(x,y) – raise x to the yth power. • ceil(x), floor(x) …and more

50. Exercise Write a function that uses the formula 2/6=1/1+1/4+1/9+1/16+…+1/n2 (where n goes to infinity) in order to approximate  . The function should accept an argument n which determines the number of terms in the formula. It should return the approximation of . Write a program that gets an integer n from the user, and approximate  using n terms of the above formula.