Arrays

Views:
 
Category: Entertainment
     
 

Presentation Description

No description available.

Comments

Presentation Transcript

C arrays:

C arrays (Reek, Ch. 8) 1 CS 3090: Safety Critical Programming in C

Review of arrays:

Review of arrays CS 3090: Safety Critical Programming in C 2 There are no array variables in C – only array names Each name refers to a constant pointer Space for array elements is allocated at declaration time Can’t change where the array name refers to… but you can change the array elements, via pointer arithmetic int m[4]; ( int []) m ??? ( int ) ??? ( int ) ??? ( int ) ??? ( int )

Subscripts and pointer arithmetic:

Subscripts and pointer arithmetic CS 3090: Safety Critical Programming in C 3 array[subscript] equivalent to *(array + (subscript)) Strange but true: Given earlier declaration of m , the expression 2[m] is legal! Not only that: it’s equivalent to *(2+m) *(m+2) m[2]

Array names and pointer variables, playing together:

Array names and pointer variables, playing together CS 3090: Safety Critical Programming in C 4 int m[3]; int *mid = m + 1; int *right = mid[1]; int *left = mid[-1]; int *beyond = mid[2]; ( int []) beyond ??? ( int ) ??? ( int ) ??? ( int ) ( int []) ( int []) ( int []) ( int []) mid right left m subscript OK with pointer variable compiler may not catch this – runtime environment certainly won’t

Array names as function arguments:

In C, arguments are passed “by value” A temporary copy of each argument is created, solely for use within the function call void f( int x, int *y) { … } void g(…) { int a = 17, b = 42; f(a, &b); … } Pass-by-value is “safe” in that the function plays only in its “sandbox” of temporary variables – can’t alter the values of variables in the callee (except via the return value) Array names as function arguments CS 3090: Safety Critical Programming in C 5 17 ( int ) 42 ( int ) g b 17 ( int ) x y ( int []) f a

Array names as function arguments:

Array names as function arguments CS 3090: Safety Critical Programming in C 6 But, functions that take arrays as arguments can exhibit what looks like “pass-by-reference” behavior, where the array passed in by the callee does get changed Remember the special status of arrays in C – They are basically just pointers. So arrays are indeed passed by value – but only the pointer is copied, not the array elements! Note the advantage in efficiency (avoids a lot of copying) But – the pointer copy points to the same elements as the callee’s array These elements can easily be modified via pointer manipulation

Array names as function arguments:

Array names as function arguments CS 3090: Safety Critical Programming in C 7 The strcpy “string copy” function puts this “pseudo” call-by-reference behavior to good use void strcpy(char *buffer, char const *string); void f(…) { char original[4] = ″dog″; char copy[4]; strcpy(copy, original); } (char []) original d (char) o (char) g (char) NUL (char) (char []) copy ??? (char) ??? (char) ??? (char) ??? (char) f (char []) string (char []) buffer strcpy d (char) o (char) g (char) NUL (char)

When can array size be omitted?:

When can array size be omitted? CS 3090: Safety Critical Programming in C 8 There are a couple of contexts in which an array declaration need not have a size specified: Parameter declaration: int strlen(char string[]); As we’ve seen, the elements of the array argument are not copied, so the function doesn’t need to know how many elements there are. Array initialization: int vector[] = {1, 2, 3, 4, 5}; In this case, just enough space is allocated to fit all (five) elements of the initializer list

Multidimensional arrays:

Multidimensional arrays CS 3090: Safety Critical Programming in C 9 How to interpret a declaration like: int d[2][4]; This is an array with two elements: Each element is an array of four int values The elements are laid out sequentially in memory, just like a one-dimensional array Row-major order: the elements of the rightmost subscript are stored contiguously ( int ) ( int ) ( int ) ( int ) ( int ) ( int ) ( int ) ( int ) d[0][0] d[0][1] d[0][2] d[0][3] d[1][0] d[1][1] d[1][2] d[1][3] d[0] d[1]

Subscripting in a multidimensional array:

i nt d[2][4]; d [1] [2] Subscripting in a multidimensional array CS 3090: Safety Critical Programming in C 10 ( int ) ( int ) ( int ) ( int ) ( int ) ( int ) ( int ) ( int ) d[0][0] d[0][1] d[0][2] d[0][3] d[1][0] d[1][1] d[1][2] d[1][3] d[0] d[1] *(d+1) *(*(d+1)+2) Increment by the size of 1 array of 4 int s Then increment by the size of 2 int s

Why do we care about storage order?:

Why do we care about storage order? CS 3090: Safety Critical Programming in C 11 If you keep within the “paradigm” of the multidimensional array, the order doesn’t matter… But if you use tricks with pointer arithmetic, it matters a lot It also matters for initialization To initialize d like this: use this: int d[2][4] = {0, 1, 2, 3, 4, 5, 6, 7}; rather than this int d[2][4] = {0, 4, 1, 5, 2, 6, 3, 7}; 0 1 2 3 4 5 6 7

Multidimensional arrays as parameters:

Multidimensional arrays as parameters CS 3090: Safety Critical Programming in C 12 Only the first subscript may be left unspecified void f(int matrix[][10]); /* OK */ void g(int (*matrix)[10]); /* OK */ void h(int matrix[][]); /* not OK */ Why? Because the other sizes are needed for scaling when evaluating subscript expressions (see slide 10) This points out an important drawback to C: Arrays do not carry information about their own sizes! If array size is needed, you must supply it somehow (e.g., when passing an array argument, you often have to pass an additional “array size” argument) – bummer

authorStream Live Help