C programming language continued: Recursion, strings and pointer

Transcription

1 C programming language continued: Recursion, strings and pointer By Nachanon Vetjasit (Sep, 2014) #0 #1 #2 #3 #4 #5 #6 #7 #8 P o i n t M 0x20

2 Recursion Recursion, is basically an act that function calls itself. But uncontrolled recursion will make program call itself repeatedly, deeper and deeper without ending, which is not very useful. At the end, you probably ended up with stack overflow. Which in Java, you might see it as java.lang.stackoverflowerror.

3 Recursion So, the important thing is to make sure that program will eventually reach the end case. (Or base case, if you prefer that term)

4 Recursion Recursion of function in C is not really different from Java. So I ll just give a brief example.

5 Factorial A classic example of recursive function. But can be calculated in iterative fashion too: If you think of factorial this way: or n! = (n-1) n n! = n (n-1) This is an iterative way to calculate it.

6 Which leads to the code like this: int factorial(int n) { int result = 1; int i; for(i=1;i<=n;i++) { result*=i; } return result; } n

7 Factorial But If you think of factorial this way: n! = n (n-1)! ; n>1 (Recursive case) n! = 1 ; n<=1 (End case) This is a recursive way to calculate it.

8 Which leads to the code like this: int factorial(int n) { if(n>=1) { return n*factorial(n-1); } else { } } return 1; End case Recursive case

9 String manipulation First and foremost: WARNING Doing a simple thing like this: char array[5]; array[10]='h'; can do damages to your program. C will not detect it, and it will silently overwrite other variables. So be aware of your array size.

10 String manipulation To use string-related function in C, you should add #include <string.h> at the beginning of your source file.

11 String length int strlen(char[] str); This will return the length of specified string. Equivalent in Java is String.length(). For example: int main() { int len; len=strlen("hello World"); printf("%d\n",len); return 0; } len will be equals to 11

12 IMPORTANT: String in C is mutable, unlike string in Java (which is immutable). Manipulating string in Java will create new strings. (Original one is unchanged) Manipulating string in C will change that very string. So you'd better have a backup copy if you need to keep the original for later use.

13 String copying char[] strcpy(char des[], char src[]); This will copy source string to the destination. Note: Returned value is just the destination string. IMPORTANT: You must already reserved enough space (plus null terminator) in the destination array.

14 #include <stdio.h> #include <string.h> int main() { char str1[12]="hello World"; char str2[12]; strcpy(str2,str1); printf("%s\n",str2); return 0; } str2 now have "Hello World" content.

15 String concatenation char[] strcat(char des[], char src[]); This will append source string to the end of destination string; analogue to the String.concat() method in Java, but it really modify the destination string. Note: Returned value is just the destination string. IMPORTANT: You must already reserved enough space in the destination array. (Original destination length, plus source length, plus null terminator)

16 #include <stdio.h> #include <string.h> int main() { char str1[11]="hello"; char str2[6]="world"; strcat(str1,str2); printf("%s\n",str1); return 0; } str1 now have "HelloWorld" content.

17 String comparison int strcmp(char str1[],char str2[]); This will compare both strings. Analogue to Java's String.equals(). Returns: Zero, if both string are equal. Nonzero, otherwise.

18 You might ask that "Why didn't they just make it return 1 if equals, and 0 if not!? So it'd be straightforward when used in if statement!" Well, because strcmp is really returns two string's relative position in ASCIIbetical * order: 1 if first string comes after the second -1 if first string comes before the second 0 if first string is the same as second * ASCIIbetical order is like dictionary order, but uppercase comes before lower case character.

19 #include <stdio.h> #include <string.h> int main() { char inp1[20]; char inp2[20]; scanf("%s",inp1); scanf("%s",inp2); if(strcmp(inp1,inp2)==0) printf("both string are equal."); else printf("both string are unequal."); }

20 Hazard of accessing array #include <stdio.h> #include <string.h> 5-character array; 4 character max for input int main() { char str[5]; int passed=0; } gets() didn't limit length of user input gets(str); if(strcmp(str,"kill")==0) { passed=1; } if(passed) { printf("access Granted\n"); /* Do some privileged things here */ } else { printf("access Denied\n"); } return 0; Hint: password "KILL"

21 Entering correct password: "KILL". $./pwtest KILL Access Granted $ Entering wrong password: "LOVE" $./pwtest LOVE Access Denied $

22 Entering wrong password, but with length exceeding 4 characters: $./pwtest Supercalifragilisticexpialidocious Access Granted Segmentation fault $ This error is called buffer overflow. If you didn't take care of limiting user input's length, it can be a difficult-to-debug bug, or worse, a security hole.

23 Pointer and memory Computer didn't see memory the way we do. Only things computer see on system memory are an array of bytes. No variables, no type. Each byte have its reference number, called address.

24 It's like a row of lockers, each locker has a number assigned, and each locker can contain content of one integer variable. #0 #1 #2 #3 #4 #5 #6 #7 #8

25 When you declare int a; Compiler will reserve the first locker, and it will remember that locker number (locker #0) as variable a. a #0 #1 #2 #3 #4 #5 #6 #7 #8

26 When you add another declaration: int a; int b; Compiler will reserve the next free locker (locker #1) and remember it as variable b. a b #0 #1 #2 #3 #4 #5 #6 #7 #8

27 When you assigned value to the variables a = 10; b = 15; values will end up in variables' respective locker. a b #0 #1 #2 #3 #4 #5 #6 #7 #

28 There's also a weird kind of variable, a pointer. Declared like this: int *p; Like normal variable, it have its own locker. a b p #0 #1 #2 #3 #4 #5 #6 #7 #

29 But its locker content is not used directly; It is used for storing other locker's number. So we can access the content there. a b p #0 #1 #2 #3 #4 #5 #6 #7 #

30 To be usable, you need to specify the locker number to point to. But since assigning using number is not flexible, (since program can be relocated to anywhere in the memory) we assign the pointer to point to specific variable's locker. a b p #0 #1 #2 #3 #4 #5 #6 #7 #

31 We do this by using address operator (&). p = &a; This means: put the number of variable a's locker into locker p. (a.k.a. put the memory address of variable a into variable p) a b p #0 #1 #2 #3 #4 #5 #6 #7 #

32 The real value of pointer variable is just target's locker number. (In this case, if you printed it out, it will show 0) a b p #0 #1 #2 #3 #4 #5 #6 #7 #

33 But if you want to access what pointer pointed to, you need to use dereference operator (*). *p /* This gives a value of 10 */ You can also assign some value to it too *p = 20; and this value will end up in locker that have it's number in locker p. (In this case, locker #0) a b p #0 #1 #2 #3 #4 #5 #6 #7 #

34 Now, if you print out the value of variable a, you will get 20. a b p #0 #1 #2 #3 #4 #5 #6 #7 #

35 You can have pointer that point to pointer too. int **pt; pt=&p; Dereferencing one time: *pt will give you the value of locker that pt points to: value of pointer p. Dereferencing two time: **pt will give you the value of locker that p points to: value of variable a. a b p pt #0 #1 #2 #3 #4 #5 #6 #7 #

36 You're able to not just accessing the locker that pointer points to, you can access nearby locker, by adding or subtracting the value of pointer before dereferencing. p=&b; printf("%d\n", *(p+1) ); printf("%d\n", *(p-1) ); This gives the value 0. a b p This gives the value 20. #0 #1 #2 #3 #4 #5 #6 #7 #

37 You can access the pointer as an array too. Since in C, array is actually a pointer in disguise. Using p[0] is equivalent to *p. It means go to the locker pointed by p, then move forward for 0 step. Using p[1] is equivalent to *(p+1), and so on. (Negative index is also accepted) a b p #0 #1 #2 #3 #4 #5 #6 #7 #

38 In real life, there are more complications: One locker is one byte. One variable can span to multiple locker, depends on type. So variable type (length) must be taken into consideration. And first locker is not conveniently numbered 0. 0x00 0x00 0x00 0x14 0x00 0x00 0x00 0x0F 0x4A 0x15 0x04 0x4A x4A x4A x4A x4A x4A x4A x4A x4A15045A 0x4A15045B 0x4A15045C 0x56 0x4A15045D a Integer: 4 bytes b Integer: 4 bytes p Pointer: 4 bytes

39 0x00 0x00 0x00 0x14 0x00 0x00 0x00 0x0F 0x4A 0x15 0x04 0x4A x4A x4A x4A x4A x4A x4A x4A x4A15045A 0x4A15045B 0x4A15045C 0x56 0x4A15045D a Integer: 4 bytes b Integer: 4 bytes p Pointer: 4 bytes When we say that p points to integer b, p actually points to the first byte of integer b. The thing that tell compiler that we point to four bytes is the type that pointer p was declared with: int *p;

40 0x00 0x00 0x00 0x14 0x00 0x00 0x00 0x0F 0x4A 0x15 0x04 0x4A x4A x4A x4A x4A x4A x4A x4A x4A15045A 0x4A15045B 0x4A15045C 0x56 0x4A15045D a Integer: 4 bytes b Integer: 4 bytes p Pointer: 4 bytes This thing is also affects how pointer's array index (and pointer arithmetic) works. For integer pointer, p+1 or p[1] actually moves for 4 bytes. (Assume that integer size is 4 byte) For double pointer, it moves for 8 byte. For char type, 1 byte.

41 Why do we need pointers? Because C is designed for OS programming, you need to be able to access every bit of system memory. You can't declare variable for all of it. So, with pointer, we have a variable that point to an address of any memory, so we could read and write to throughout them.

42 Note: The size of pointer variable itself did not depend on data type it points to, but rather an address space size of that CPU architecture. For intel i386 (32-bit): 4 byte For intel x86-64 (64-bit): 8 byte

43