Download presentation
Presentation is loading. Please wait.
1
C Tutorial (part 5) CS220, Spring 2012
Slides based on 213 slides. Modified example slightly and removed all assembly and assembly related content.
2
Array Allocation Basic Principle T A[L];
Array of data type T and length L Contiguously allocated region of L * sizeof(T) bytes char string[12]; x x + 12 int val[5]; x x + 4 x + 8 x + 12 x + 16 x + 20 double a[3]; x + 24 x x + 8 x + 16 char *p[3]; x x + 4 x + 8 x + 12 IA32 x x + 8 x + 16 x + 24 x86-64
3
Array Access Basic Principle Reference Type Value Will disappear
T A[L]; Array of data type T and length L Identifier A can be used as a pointer to array element 0: Type T* Reference Type Value val[4] int 3 val int * x val+1 int * x + 4 &val[2] int * x + 8 val[5] int ?? *(val+1) int 5 val + i int * x + 4 i int val[5]; 1 5 2 3 x x + 4 x + 8 x + 12 x + 16 x + 20 Will disappear Blackboard?
4
Array Access Basic Principle Reference Type Value T A[L];
Array of data type T and length L Identifier A can be used as a pointer to array element 0: Type T* Reference Type Value val[4] int 3 val int * x val+1 int * x + 4 &val[2] int * x + 8 val[5] int ?? *(val+1) int 5 val + i int * x + 4 i int val[5]; 1 5 2 3 x x + 4 x + 8 x + 12 x + 16 x + 20
5
Array Example Int cs[5] = { 1, 5, 2, 1, 3 }; Int ece[5] = { 0, 2, 1, 3, 9 }; Int me[5] = { 9, 4, 7, 2, 0 }; cs: 1 5 2 3 16 20 24 28 32 36 ece: 2 1 3 9 36 40 44 48 52 56 me: 9 4 7 2 56 60 64 68 72 76 Example arrays were allocated in successive 20 byte blocks Not guaranteed to happen in general
6
Referencing Examples Reference Address Value Guaranteed?
cs; 1 5 2 3 16 20 24 28 32 36 ece; 2 1 3 9 36 40 44 48 52 56 me; 9 4 7 2 56 60 64 68 72 76 Reference Address Value Guaranteed? ece[3] * 3 = 48 3 ece[5] * 5 = 56 9 me[-1] *-1 = 32 3 cs[15] *15 = 76 ?? Will disappear Blackboard?
7
Referencing Examples Reference Address Value Guaranteed? Yes No
cmuq; 1 5 2 3 16 20 24 28 32 36 tamuq; 2 1 3 9 36 40 44 48 52 56 nwq; 9 4 7 2 56 60 64 68 72 76 Reference Address Value Guaranteed? ece[3] * 3 = 48 3 ece[5] * 5 = 56 9 ece[-1] *-1 = 32 3 cs[15] *15 = 76 ?? No bound checking Out of range behavior implementation-dependent No guaranteed relative allocation of different arrays Yes No No No
8
Nested Array Example “Row-Major” ordering of all elements guaranteed
int ec[4][5] = {{1, 5, 2, 0, 6}, {1, 5, 2, 1, 3 }, {1, 5, 2, 1, 7 }, {1, 5, 2, 2, 1 }}; 1 5 2 6 1 5 2 3 1 5 2 7 1 5 2 ec 76 96 116 136 156 “Row-Major” ordering of all elements guaranteed What data type is ec? What is its value? What data type is ec[2]? What is its value? What data type is ec[1][1]? What is its value?
9
Multidimensional (Nested) Arrays
Declaration T A[R][C]; 2D array of data type T R rows, C columns Type T element requires K bytes Array Size R * C * K bytes Arrangement Row-Major Ordering A[0][0] A[0][C-1] A[R-1][0] • • • A[R-1][C-1] • int A[R][C]; • • • A [0] [C-1] [1] [R-1] • • • 4*R*C Bytes
10
Nested Array Row Access
Row Vectors A[i] is array of C elements Each element of type T requires K bytes Starting address A + i * (C * K) int A[R][C]; • • • A [0] [C-1] A[0] • • • A [i] [0] [C-1] A[i] • • • A [R-1] [0] [C-1] A[R-1] • • • • • • A A+i*C*4 A+(R-1)*C*4
11
Strange Referencing Examples
1 5 2 6 1 5 2 3 1 5 2 7 1 5 2 76 96 116 136 156 Reference Address Value Guaranteed? ec[3][3] 76+20*3+4*3 = 148 2 ec[2][5] 76+20*2+4*5 = 136 1 ec[2][-1] 76+20*2+4*-1 = 112 3 ec[4][-1] 76+20*4+4*-1 = 152 1 ec[0][19] 76+20*0+4*19 = 152 1 ec[0][-1] 76+20*0+4*-1 = 72 ?? Will disappear
12
Strange Referencing Examples
1 5 2 6 1 5 2 3 1 5 2 7 1 5 2 ec[4][5]; 76 96 116 136 156 Reference Address Value Guaranteed? ec[3][3] 76+20*3+4*3 = 148 2 ec[2][5] 76+20*2+4*5 = 136 1 ec[2][-1] 76+20*2+4*-1 = 112 3 ec[4][-1] 76+20*4+4*-1 = 152 1 ec[0][19] 76+20*0+4*19 = 152 1 ec[0][-1] 76+20*0+4*-1 = 72 ?? Code does not do any bounds checking Ordering of elements within array guaranteed Yes Yes Yes Yes No
13
Multi-Level Array Example
Variable univ denotes array of 3 elements Each element is a pointer 4 bytes Each pointer points to array of int’s int cs = { 1, 5, 2, 1, 3 }; int ece = { 0, 2, 1, 3, 9 }; int me = { 9, 4, 7, 2, 0 }; #define DCOUNT 3 int *ec[DCOUNT] = {ece, cs, me}; cs 1 5 2 3 16 20 24 28 32 36 36 160 16 56 164 168 ec ece 2 1 3 9 36 40 44 48 52 56 me 9 4 7 2 56 60 64 68 72 76
14
Array Element Accesses
Nested array cs Multi-level array 1 5 2 3 16 20 24 28 32 36 36 160 16 56 164 168 ec ece 2 1 3 9 36 40 44 48 52 56 me 9 4 7 2 56 60 64 68 72 76 ec[index][dig] looks similar, but element: Mem[ec+20*index+4*dig] Mem[Mem[ec+4*index]+4*dig]
15
Strange Referencing Examples
cs 1 5 2 3 16 20 24 28 32 36 36 160 16 56 164 168 ec ece 2 1 3 9 36 40 44 48 52 56 me 9 4 7 2 56 60 64 68 72 76 Reference Address Value Guaranteed? ec[2][3] 56+4*3 = 68 2 ec[1][5] 16+4*5 = 36 0 ec[2][-1] 56+4*-1 = 52 9 ec[3][-1] ?? ?? ec[1][12] 16+4*12 = 64 7 Will disappear
16
Strange Referencing Examples
cmuq 1 5 2 3 16 20 24 28 32 36 36 160 16 56 164 168 ec tamuq 2 1 3 9 36 40 44 48 52 56 nwq 9 4 7 2 56 60 64 68 72 76 Reference Address Value Guaranteed? ec[2][3] 56+4*3 = 68 2 ec[1][5] 16+4*5 = 36 0 ec[2][-1] 56+4*-1 = 52 9 ec[3][-1] ?? ?? ec[1][12] 16+4*12 = 64 7 Code does not do any bounds checking Ordering of elements in different arrays not guaranteed Yes No No No No
Similar presentations
© 2025 SlidePlayer.com. Inc.
All rights reserved.