1. Senem Kumova Metin // CS115 // 2008-20091 FUNCTIONS continues CHAPTER 5

2. Senem Kumova Metin // CS115 // 2008-20092 1.CALL BY VALUE 2.DEVELOPING A LARGE PROGRAM 3.SCOPE RULES 4.STORAGE CLASSES 5.RECURSION

3. Senem Kumova Metin // CS115 // 2008-20093 CALL BY VALUE If a variable is passed to a function, the stored value in the calling environment will not be changed!!! EXAMPLE: #include int my_sum(int n); void main(void) {int n=9; printf(“%d\n”,n); printf(“%d\n”,my_sum(n)); // call function my_sum() by value printf(“%d\n”,n); } int my_sum(int n) { n=n+2; // stored value of n in my_sum() is changed return n; } OUTPUT ??

4. Senem Kumova Metin // CS115 // 2008-20094 Developing a large program read 5.8 (pg 209) /* my_program.c */ #include”my_header.h” void main(void) { int a=3, b=4, result=0; result=my_sum(a,b); printf(“%d\n”,result); result=my_subtract(a,b); printf(“%d\n”,result); printf(“%f\n”,PI); } /* my_header.h */ #include #define PI 3.14 int my_sum(int x,int y) { x++; y++; return x+y; } int my_subtract(int x, int y) {return x-y-1; }

5. Senem Kumova Metin // CS115 // 2008-20095 SCOPE RULES Each identifier is accessible only within the block in which it has been declared!!! EXAMPLE: #include void func_1 (int a) {int b, c; } void func_2 (int a, double b, float d) { char c; } void main () { int a,b,d; char c; } func1() variables abc abdc func2() variables abcd main() variables

6. Senem Kumova Metin // CS115 // 2008-20096 SCOPE RULES : EXAMPLE # include void main (void) {int a=2; float b=3.2; // outer block a printf("%d\n",a); {int a =5; // inner block a printf("%d\n", a); printf("%f\n", a+b); { int b=4; printf("%d\n“, a+b); } printf("%d\n",++a); } OUTPUT: 2 5 8.200000 9 3

7. Senem Kumova Metin // CS115 // 2008-20097 STORAGE CLASSES  EACH VARIABLE HAS A TYPE AND A STORAGE CLASS  STORAGE CLASSES 1.auto /* variables declared within function bodies are automatic by default */ 2.extern /* look for it elsewhere either in this file or in some other file */ 3.register 4.static  EXAMPLE extern int a=1; /* type of variable a is int, storage class of a is extern */ auto float f; float z; /* storage class is auto and data type is float */

8. Senem Kumova Metin // CS115 // 2008-20098 STORAGE CLASSES 2. EXTERN The keyword extern is used to tell the compiler to "look for it elsewhere, either in this file or in some other file" External variables never disappear. Because they exist throughout the execution life of the program, they can be used to transmit values across functions ( GLOBAL)

9. Senem Kumova Metin // CS115 // 2008-20099 STORAGE CLASSES 2. EXTERN /* file1.h */ int f(void) { extern int a; /* look for it elsewhere */ int b, c; // local b and c a = b = c = 4; // global b anc c are masked return (a + b + c); } /* prog1.c*/ #include #include ”file1.h” int a = 1, b = 2, c = 3; /* global variables */ int f(void); int main(void) { printf("%3d%3d%3d\n", a, b, c); printf("%3d\n", f() ); printf("%3d%3d%3d\n", a, b, c); return 0; } OUTPUT: 1 2 3 12 4 2 3

10. Senem Kumova Metin // CS115 // 2008-200910 STORAGE CLASSES 3. REGISTER Forces compiler that these variables should be stored in high speed memory registers Compiler may or may not store them in registers Reading data from registers is faster comparing to reading from memory EXAMPLES: register char c; register int a=1; /* IS EQUIVALENT TO */ register a=1; // default data type is int

11. Senem Kumova Metin // CS115 // 2008-200911 STORAGE CLASSES 4. STATIC Memory opened for the static variable will not be closed after the execution of the function Initialization for static variables is done just once in the first execution of the function EXAMPLE: #include int ver(); main() {printf(“1. value=%d\n”, ver() ); printf(“2. value=%d\n”, ver() ); printf(“3. value=%d\n”, ver() ); } int ver() {static int k =0; k=k+5; return k; } OUTPUT 1. value=5 2. value=10 3. value=15

12. Senem Kumova Metin // CS115 // 2008-200912 STORAGE CLASSES STATIC EXTERNAL VARIABLES Can be seen below the prototype/declaration but can not be seen in any other file Scope restricted Cannot be used with functions defined earlier or in any other files Program security !! EXAMPLE : #include void f(void) {...... } // v is not available static int v; // static external variable void g(void) {..... } // you can use v

13. Senem Kumova Metin // CS115 // 2008-200913 RECURSION An algorithmic technique where a function, in order to accomplish a task, calls itself with some part of the task If a function calls itself, then it is called recursive !!! There are two parts to the definition of a recursive solution: –Base case: Simple, non-recursive solution –General method: Uses simpler version of the problem to solve harder problem

14. Senem Kumova Metin // CS115 // 2008-200914 RECURSION : EXAMPLES void main(void) { printf(“I am calling myself!\n”); main(); } /* NO BASE CASE SO IT WILL NEVER STOP */ #include void rev( ) { char ch; ch=getchar(); if (ch != '\n') rev(); putchar(ch);} // BASE CASE ch=‘\n’ int main( ) { rev();}

15. Senem Kumova Metin // CS115 // 2008-200915 RECURSION : EXAMPLES // ITERATION int sum(int N) { int i; int SUM =0; for (i=1; i<=N; i++) SUM=SUM+1; return SUM; } // RECURSION int sum(int N) { if(N==1) return 1; else return(N+sum(N-1));} /* BASE CASE : N==1  1 METHOD : sum(N) = N + sum(N-1) if BASE CASE else METHOD */

16. Senem Kumova Metin // CS115 // 2008-200916 RECURSION : EXAMPLES BASE CASE  N=1 return 1 METHOD  sum(N)= sum(N-1)+1/N double sum(int N) {if(N==1) return 1; else return (sum(N-1)+1/N); }

17. Senem Kumova Metin // CS115 // 2008-200917 RECURSION & ITERATION EXAMPLE : FACTORIAL /*iterative version n! = 1*2*3* … * n = n*(n-1)*(n-2) * …*3*2*1 */ int factorial (int n) { int product=1; for(;n>1;--n) product=product*n; return product;} /* recursive version n! = n * (n-1)! */ int factorial(int n) { if(n<=1) return 1; else return ( n*factorial(n-1) ); } /* BASE CASE : n<=1  1 METHOD : n!=n*(n-1)! */ factorial(3) = 3 * factorial(2) = 3 * ( 2 * factorial(1) ) = 3 * ( 2 * ( 1 * factorial(0) )) = 3 * ( 2 * ( 1 * 1 ) )) = 6

18. Senem Kumova Metin // CS115 // 2008-200918 RECURSION & ITERATION EXAMPLE : POWER /*iterative version x n = x*x*x* … *x */ /* Assume that n is always positive*/ int power (int x, int n) { int result=1; int i; for(i=1; i<=abs(n); i++) result=result*x; } /* recursive version x n = x n-1 * x */ /* Assume that n is always positive */ int power(int x, int n) { if(n==1) return x; else return ( x* power(x,n-1) ); } /* BASE : n==1  1 METHOD : power(x,n)= power(x,n-1)*x */ power(3,4) = 3 * power(3,3) = 3 * ( 3 * power(3,2) ) = 3 * ( 3 * ( 3 * power(3,1) )) = 3 * ( 3 * ( 3 * 3 ) ) = 81

19. Senem Kumova Metin // CS115 // 2008-200919 RECURSION EXAMPLE : FIBONACCI In mathematics, the Fibonacci numbers form a sequence definedmathematicssequence recursivelyrecursively by for n=0  fibonacci(0) = 0 fibonacci (n) = for n=1  fibonacci(1) = 1 for n >1  fibonacci(n) = fibonacci(n-1) + fibonacci(n-2) int fibonacci(int n) { if(n<=1) return 1; else return ( fibonacci(n-1)+fibonacci(n-2) );} /* BASE CASE : n<=1  1 METHOD : fibonacci(n)=fibonacci(n-1)+ fibonacci(n-2)*/

20. Senem Kumova Metin // CS115 // 2008-200920 YOUR HOMEWORK TOWERS OF HANOI