Izmir Institute of Technology CE Lecture 8. References: - C: A software Engineering Approach 1

Transcription

1 Izmir Institute of Technology CE Lecture 8 References: - C: A software Engineering Approach 1

2 In this course you will learn Array assignment Pointer Arithmetic Passing Pointers as Function Arguments Strings 2

3 In this course you will learn Array assignment Pointer Arithmetic Passing Pointers as Function Arguments Strings 3

4 Initializing Arrays You may initialize the variable by using the static keyword as follows. #include <stdio.h> main() { int i; static int ar_a[5]; static int ar_b[5]={2, 3.1, 5; for (i=0; i<5; i++) printf(" %d %d\n", ar_a[i], ar_b[i]); return 0; gursoy@0[~]$ gcc foo.c gursoy@0[~]$./a.out gursoy@0[~]$ 4

5 Pointer Arithmetic You may add or subtract integer values from pointers. For example, if p is a pointer, then p + 2 is perfectly legal. If a is an array, then &a[3] - &a[0] is also legal, and the result is equal to 3. 5

6 Pointer Arithmetic main() { long int *p1, *p2; int j; char *p3; p2 = p1 + 4; /* legal */ j = p2 p1; /* legal j is assigned 4 */ j = p1 p2; /* legal j is assigned -4 */ p1 = p2 2; /* legal compatible pointer types*/ p3 = p1 1; /* illegal different pointer types */ j = p1 p3; /* illegal different pointer types */ 6

7 Passing Pointers as Function Arguments Attention: We have seen that mixed types produce an error. However, a pointer may be passed to a function that treats it as another type. Investigate the following example. //++++ file1.c #include <stdio.h> int main() { static short s[6]={1,2,3,4; /* clear element 1 of s[]. */ clr( &s[1] ); //++++ file2.c void clr( p ) int *p; { /* Store a zero at location p*/ *p = 0; printf(" s[0]= %d\n", s[0]); printf(" s[1]= %d\n", s[1]); printf(" s[2]= %d\n", s[2]); printf(" s[3]= %d\n", s[3]); return 0; 7

8 Passing Pointers as Function Arguments gcc file1.c file2.c s[0]=1 s[1]=0 s[2]=0 s[3]=4 The reason is that the pointer in function clr() is declared as an integer, whereas the address that is passed to the function clr() is a short integer. A short integer takes up 2 bytes, and an integer takes up 4 bytes. The pointer clears 4 bytes clearing s[1] and s[2]. 8

9 Passing Pointers as Function Arguments Element Memory Address Contents 2 bytes s[0] s[1] s[2] s[3] 0x x x x bytes p 0x7fffd74683f8 0x

10 Accessing Array Elements through Pointers Source Code #include <stdio.h> main() { short ar[4]; short e; short *p; p = &ar[0]; Explanation declare a short array ar with 4 elements; declare a short integer e; declare a pointer of type short; assign the address of array element 0 to p; for (e=0; e<4; e++) { printf("%d \n", ar[e] ); for (e=0; e<4; e++) { printf("%d \n", *(p+e) ); return( 0 ); for e=0-3, print ar[e]; for e=0-3, print *(p+e); 10

11 Accessing Array Elements through Pointers First important Relationship ar[0] is equivalent to *p ar[e] is equivalent to *(p+e) Second important Relationship An array name that is not followed by a subscript is interpreted as a pointer to the initial element of the array. ar is equivalent to &ar[0] and since, ar = &ar[0], we end up with ar[e] is equivalent to *(ar + e) 11

12 Accessing Array Elements through Pointers There are some restrictions on the Pointer type array float ar[5], *p; p = ar; ar = p; &p = ar; ar++; ar[1] = *(p+3); p++; /* legal: same as p = &ar[0] */ /* illegal: you may not assign to an */ /* array address */ /* illegal: you may not assign to an */ /* array address */ /* illegal: you may not increment */ * an array address */ /* legal: ar[1] is a variable */ /* legal: you may increment a */ /* pointer variable */ 12

13 Passing Arrays as Functions Arguments #include <stdio.h> main() /* sum up all elements of a vector (x,y,z) */ { float result, ar[]={1.0, 3.0, 5.0; float vsum(); result = vsum(ar); printf("the sum = %f \n", result); return( 0 ); float vsum(vec) float vec[]; { int i; float result=0.0; Pointer to the array - ar The compiler understands that this is a pointer to an array. for (i=0; i<3; i++) { result = result + *(vec + i); return result; Compile with: gcc foo.c run with:./a.out The sum =

14 Walking off the End of an Array Investigate the following program, which intends to initialize the (make it equal to zero) array, ar. #include <stdio.h> main() { int ar[10]; int i; for (i=0; i<=10; i++) { ar[i] = 0; return( 0 ); What will happen? Is it possible that the computer will crash? Be careful! 14

15 Strings Example: yes or Hello! One of the most common uses of arrays is to store strings of characters. A string is an array of characters terminated by a null character - '\0'. Each character in a string takes up one byte. The compiler appends the null character to designate the end of the string. 15

16 Declaring and Initializing Strings Strings are declared as arrays and of type char. Example: static char str[6]; For some compilers, the array must be one element longer than the number of characters that are to be stored in it. Then, in the above example, a maximum number of 5 characters can be stored. It is allowed to store less characters than the size of the array. Ex: static char str[10] = Hello! ; 16

17 Declaring and Initializing Strings It is not allowed to assign more characters than the number of elements in an array. Ex: static char str[3] = This is not allowed ; You may also initialize a char pointer with a string constant. Ex: static *pstr = This is the file foo.c ; 17

18 String Assignments The reason you can initialize a pointer with a string constant is that a string is an array of characters. string constants in C are like other arrays. C interprets a string constant as a pointer to the first character of the string. You can assign a string constant to a pointer that points to char. 18

19 String Assignments Line 1 Line 2 Line 3 Line 4 Line 5 Line 6 Line 7 Line 8 Line 9 Line 10 Line 11 Line 12 Line 13 Line 14 Line 15 Line 16 Line 17 Line 18 #include <stdio.h> main() { char array[10]; char *ptr1 = "10 spaces"; char *ptr2; array = "not OK"; array[5] = 'A'; ptr1[5] = "B ; ptr1 = "OK"; ptr1[2] = "C"; *ptr2 = "not OK"; ptr2 = "OK"; printf("%s\n", ptr1); return(0); Write the C code on the left only with one line number ( 8 14) at a time. Otherwise, during compilation, the compiler may only complain at the first error, and not about the rest. 19

20 String Assignments Lets discuss each assignment in detail: array = not OK ; array represents the address of the initial element of the array, so it cannot be changed. array[5] = 'A'; This is a simple assignment to element 5 of the char array[]. ptr1[5] = B ; ptr1 is a pointer to a char that has been initialized to point to the string 10 spaces, which exists somewhere in memory. Because of the pointer array equivalence, this assignment changes the value of element 5. However, in the recent compilers, this feature does not work anymore. Therefore you should not use it. 20

21 String Assignments ptr1 = OK ; This assignment changes the value of ptr1 so that it now points to a string OK, which exists somewhere else in memory. ptr1[5] = C ; Due to the prior assignment, ptr1 points to a string whose contents are OK. Including the terminating null character, this string takes up three bytes of memory. This assignment attempts to assign a value to a memory location3 bytes beyond the terminating null character in OK, thereby accessing memory whose contents are unknown This will not produce a compile-time error, but it will very likely produce a runtime error or erroneous result. 21

22 String Assignments *ptr2 = not OK ; In this case, we are attempting to assign a value to the char which ptr2 points to. The string is interpreted as the address of the first character n, so this assignment is attempting to assign an address value to a char. According to the ANSI standard, this is illegal address values may be assigned only to pointer variables. Older compilers may accept this syntax, but they should at least issue a warning. ptr2 = OK ; This assignment illustrates that you can assign a string to a char pointer even if you have not initialized the pointer. There is no difference between this statement and the statement ptr1 = OK ; 22

23 In this course you have learned Array assignment Pointer Arithmetic Passing Pointers as Function Arguments Strings 23