1 / 16

C Tutorial CS220

C Tutorial CS220. Pointers, pointer arithmetic and Arrays. 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.

dahlia-rice
Télécharger la présentation

C Tutorial CS220

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. C Tutorial CS220 Pointers, pointer arithmetic and Arrays

  2. Array Allocation • Basic Principle TA[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 x + 8 x + 16 x + 24 char *p[3]; IA32 x x + 4 x + 8 x + 12 x86-64 x x + 8 x + 16 x + 24

  3. 1 5 2 1 3 Array Access • Basic Principle TA[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+1int * x + 4 &val[2]int * x + 8 val[5]int ?? *(val+1)int 5 val + iint * x + 4 i int val[5]; x x + 4 x + 8 x + 12 x + 16 x + 20 Will disappear Blackboard?

  4. 1 5 2 1 3 Array Access • Basic Principle TA[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+1int * x + 4 &val[2]int * x + 8 val[5]int ?? *(val+1)int 5 val + iint * x + 4 i int val[5]; x x + 4 x + 8 x + 12 x + 16 x + 20

  5. 1 9 0 5 4 2 7 2 1 1 3 2 0 3 9 Array Example Intcs[5] = { 1, 5, 2, 1, 3 }; Intece[5] = { 0, 2, 1, 3, 9 }; Intme[5] = { 9, 4, 7, 2, 0 }; • Example arrays were allocated in successive 20 byte blocks • Not guaranteed to happen in general cs: ece: 56 36 16 40 60 20 64 24 44 68 28 48 52 32 72 56 36 76 me:

  6. 1 9 0 5 4 2 2 7 1 3 2 1 9 0 3 Referencing Examples cs; • Reference Address Value Guaranteed? ece[3] 36 + 4* 3 = 48 3 ece[5] 36 + 4* 5 = 56 9 me[-1] 36 + 4*-1 = 32 3 cs[15] 16 + 4*15 = 76 ?? ece; me; 56 36 16 40 20 60 24 64 44 68 48 28 72 32 52 56 36 76 Will disappear Blackboard?

  7. 9 1 0 2 4 5 7 2 1 3 1 2 0 9 3 Referencing Examples cs; • Reference Address Value Guaranteed? ece[3] 36 + 4* 3 = 48 3 ece[5] 36 + 4* 5 = 56 9 ece[-1] 36 + 4*-1 = 32 3 cs[15] 16 + 4*15 = 76 ?? • No bound checking • Out of range behavior implementation-dependent • No guaranteed relative allocation of different arrays ee; me; 36 56 16 40 60 20 64 24 44 68 28 48 32 52 72 56 36 76 Yes No No No

  8. 2 1 1 1 1 5 5 5 5 2 2 2 2 1 0 1 7 3 1 6 Nested Array Example int ec[4][5] = {{1, 5, 2, 0, 6}, {1, 5, 2, 1, 3 }, {1, 5, 2, 1, 7 }, {1, 5, 2, 2, 1 }}; • “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? ec 76 96 116 136 156

  9. A[0][0] • • • A[0][C-1] • • • • • • •  •  • A [0] [0] A [R-1] [0] • • • A [1] [0] • • • • • • A [1] [C-1] A [R-1] [C-1] A [0] [C-1] A[R-1][0] • • • A[R-1][C-1] Multidimensional (Nested) Arrays • Declaration TA[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 int A[R][C]; 4*R*C Bytes

  10. A[0] A[i] A[R-1] • • • • • • A [R-1] [0] A [0] [0] • • • A [i] [0] A [0] [C-1] A [R-1] [C-1] A [i] [C-1] 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+i*C*4 A+(R-1)*C*4 A

  11. 2 1 1 1 1 5 5 5 5 2 2 2 2 0 1 1 6 1 7 3 Strange Referencing Examples • 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 ?? 76 96 116 136 156 Will disappear

  12. 2 1 1 1 1 5 5 5 5 2 2 2 2 1 1 0 6 1 7 3 Strange Referencing Examples • 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 ec[4][5]; 76 96 116 136 156 Yes Yes Yes Yes No

  13. 0 9 1 4 5 2 2 1 7 1 2 3 9 0 3 ec 36 160 16 164 56 168 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 intcs= { 1, 5, 2, 1, 3 }; intece= { 0, 2, 1, 3, 9 }; int me = { 9, 4, 7, 2, 0 }; #define DCOUNT 3 int *ec[DCOUNT] = {ece, cs, me}; cs 56 36 16 60 20 40 64 44 24 68 48 28 32 52 72 36 56 76 ece me

  14. 9 0 1 2 4 5 1 7 2 2 1 3 9 0 3 ec 36 160 16 164 56 168 Array Element Accesses Nested array cs Multi-level array ece 56 36 16 60 40 20 24 64 44 48 68 28 52 32 72 36 56 76 me ec[index][dig] looks similar, but element: Mem[Mem[ec+4*index]+4*dig] Mem[ec+20*index+4*dig]

  15. 9 0 1 2 4 5 7 1 2 1 2 3 9 0 3 ec 36 160 16 164 56 168 Strange Referencing Examples cs • 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 ece me 56 16 36 20 40 60 24 44 64 48 68 28 52 72 32 36 76 56 Will disappear

  16. 1 9 0 2 5 4 2 1 7 2 1 3 3 0 9 ec 36 160 16 164 56 168 Strange Referencing Examples cmuq • 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 tamuq nwq 36 56 16 20 60 40 44 64 24 68 28 48 52 32 72 56 36 76 Yes No No No No

More Related