Pointers CMPE-013/L. Pointers. Pointers What do they do? Pointers What are pointers? Gabriel Hugh Elkaim Winter 2014

Size: px

Start display at page:

Download "Pointers CMPE-013/L. Pointers. Pointers What do they do? Pointers What are pointers? Gabriel Hugh Elkaim Winter 2014"

Posy Conley
6 years ago
Views:

1 CMPE-013/L A Variable's versus A Variable's Value In some situations, we will want to work with a variable's address in memor, rather than the value it contains Gabriel Hugh Elkaim Winter 2014 Variable stored at Variable name from C code int ; Value of variable = A 0123 F00D 0456 of variable = What are ointers? A ointer is a variable or constant that holds the address of another variable or function What do the do? A ointer allows us to indirectl access a variable (just like indirect addressing in assembl language) Variable at Integer Variable: Pointer Variable: 0123 Direct Access via = 00123; * = 00123; Indirect Access via * 005A 0123 F00D 0456 oints to 1

2 Wh would I want to do that? make it ossible to write a ver short loo that erforms the same task on a range of memor locations / variables. Eamle: Data Buffer //Point to RAM buffer starting address char *bufptr = &buffer; while ((DataAvailable) && (ReceivedCharacter!= '\0')) //Read bte from UART and write it to RAM buffer ReadUART(bufPtr); //Point to net available bte in RAM buffer bufptr++; Eamle: Data Buffer RAM buffer allocated over a range of addresses (erhas an arra) Pseudo-code: (1) Point arrow to first address of buffer (2) Write data from UART to location ointed to b arrow (3) Move arrow to oint to net address in buffer (4) Reeat until data from UART is 0, or buffer is full (arrow oints to last address of buffer) Wh would I want to do that? AB CDEF BDF ACE 008BA 008BC 008BE 008C0 008C2 008C4 008C6 008C8 Where else are the used? Used in conjunction with dnamic memor allocation (creating variables at runtime) Provide method to ass arguments b referenceto functions Provide method to ass more than one iece of information into and out of a function A more efficient means of accessing arras and dealing with strings Snta te *trname; Eamle How to Create a Pointer Variable In the contet of a declaration, the *merel indicates that the variable is a ointer teis the te of data the ointer ma oint to Pointer usuall described as a ointer to te int *iptr; // Create a ointer to int float *fptr; // Create a ointer to float 2

3 Snta Eamle How to Create a Pointer Te with tedef tedef te *tename; A ointer variable can now be declared as te tenamewhich is a snonm for te The *is no longer needed since tenameelicitl identifies the variable as a ointer to te tedef int *intptr; // Create ointer to int te intptr ; // Create ointer to int // Equivalent to: int *; No *is used To set a ointer to oint to another variable, we use the &oerator (address of), and the ointer variable is used withoutthe dereference oerator *: This assigns the address of the variable to the ointer (now oints to ) Note: must be declared to oint to the te of (e.g. int ; int *;) Initialization = &; Usage When accessing the variable ointed to b a ointer, we use the ointer withthe dereference oerator *: = *; This assigns to the variable, the value of what is ointing to (from the last slide) Using *, is the same as using the variable it oints to (e.g. ) Eamle int, *; &is a constant ointer Another Wa To Look At The Snta It reresents the address of The address of will never change is a variable ointer to int //int and a ointer to int = &; //Assign the address of * = 5; //Same as = 5; It can be assigned the address of an int It ma be assigned a new address an time 3

4 Eamle int, *; Another Wa To Look At The Snta //1 int, 1 ointer to int = &; //Assign the address of * = 5; //Same as = 5; Contents of Letter (integer literal 5) 5 Another Wa To Look At The Snta * = 5; Contents of the Mailbo (variable or *) of Mailbo (&) *reresents the data ointed to b *ma be used anwhere ou would use *is the dereference oerator, also called the indirection oerator In the ointer declaration, the onl significance of *is to indicate that the variable is a ointer rather than an ordinar variable on Enveloe (ointer ) = &; Bank of Mailboes (memor locations) 105 How Work How Work Eamle Eamle int, ; int *; = 0; = 0; = &; * = 00100; = &; * = 00200; Variable at 008BA 008BC 008BE 008C0 008C2 008C4 008C6 008C8 int, ; int *; = 0; = 0; = &; * = 00100; = &; * = 00200; Variable at 008BA 008BC 008BE 008C0 008C2 008C4 008C6 008C8 4

5 How Work How Work Eamle Eamle int, ; int *; = 0; = 0; = &; * = 00100; = &; * = 00200; Variable at 008BA 008BC 008BE 008C0 008C2 008C4 008C6 008C8 int, ; int *; = 0; = 0; = &; * = 00100; = &; * = 00200; Variable at 08BC 008BA 008BC 008BE 008C0 008C2 008C4 008C6 008C8 How Work How Work Eamle Eamle int, ; int *; = 0; = 0; = &; * = 00100; = &; * = 00200; Variable at BC 008BA 008BC 008BE 008C0 008C2 008C4 008C6 008C8 int, ; int *; = 0; = 0; = &; * = 00100; = &; * = 00200; Variable at BE 008BA 008BC 008BE 008C0 008C2 008C4 008C6 008C8 5

6 Eamle int, ; int *; = 0; = 0; = &; * = 00100; = &; * = 00200; How Work Variable at BE 008BA 008BC 008BE 008C0 008C2 008C4 008C6 008C8 and Arras A Quick Reminder Arra elements occu consecutive memor locations int [3] = 1,2,3; can rovide an alternate method for accessing arra elements and Arras Initializing a Pointer to an Arra The arra name is the same thing as the address of its first (0 th ) element If we declare the following arra and ointer variable: int [5] = 1,2,3,4,5; int *; We can initialize the ointer to oint to the arra using an one of these three methods: = ; //Works onl for arras! = &; //Works for arras or variables = &; //This one is the most obvious Incrementing a ointer will move it to the net element of the arra More on this in just a bit and Arras A Preview of int [3] = 1,2,3; int *; = &; ++; 6

7 and Arras A Preview of Incrementing a ointer will move it to the net element of the arra int [3] = 1,2,3; int *; = &; ++; 0800 and Arras A Preview of Incrementing a ointer will move it to the net element of the arra int [3] = 1,2,3; int *; = &; ++; More on this in just a bit More on this in just a bit Incrementing Incrementing or decrementing a ointer will add or subtract a multile of the number of btes of its te If we have: float ; float * = &; ++; We will get = & + 4since a float variable occuies 4 btes of memor Eamle float *tr; Incrementing tr = &a; tr++; Incrementing trmoves it to the net sequential float arra element Words float a[0] float a[1] float a[2] float a[3] float a[4] float a[5] float a[6] float a[7] float a[8] A 0005C 0005E A 0006C 0006E

8 Larger Jums Larger Jums Adding or subtracting an other number with the ointer will change it b a multile of the number of btes of its te If we have int ; int * = &; += 3; We will get = & + 6since an int variable occuies 2 btes of memor Eamle float *tr; tr = &a; Adding 6 to trmoves it 6 floatarra elements ahead (24 btes ahead) tr += 6; Words float a[0] float a[1] float a[2] float a[3] float a[4] float a[5] float a[6] float a[7] float a[8] A 0005C 0005E A 0006C 0006E Eamle Eamle long [3] = 1,2,3; long * = &; long [3] = 1,2,3; long * = &; * += 4; ++; * = 0; ++; * = 0F1D0F00D; -= 2; * = 0BADF00D1; 0800 * += 4; ++; * = 0; ++; * = 0F1D0F00D; -= 2; * = 0BADF00D1;

9 Eamle Eamle long [3] = 1,2,3; long * = &; long [3] = 1,2,3; long * = &; * += 4; ++; * = 0; ++; * = 0F1D0F00D; -= 2; * = 0BADF00D1; * += 4; ++; * = 0; ++; * = 0F1D0F00D; -= 2; * = 0BADF00D1; Eamle Eamle long [3] = 1,2,3; long * = &; long [3] = 1,2,3; long * = &; * += 4; ++; * = 0; ++; * = 0F1D0F00D; -= 2; * = 0BADF00D1; * += 4; ++; * = 0; ++; * = 0F1D0F00D; -= 2; * = 0BADF00D1; 0005 F00D F1D

10 Eamle Eamle long [3] = 1,2,3; long * = &; long [3] = 1,2,3; long * = &; * += 4; ++; * = 0; ++; * = 0F1D0F00D; -= 2; * = 0BADF00D1; 0005 F00D F1D * += 4; ++; * = 0; ++; * = 0F1D0F00D; -= 2; * = 0BADF00D1; 00D1 BADF F00D F1D Post-Increment/Decrement Snta Rule Post-Increment / Decrement Snta Care must be taken with resect to oerator recedence when doing ointer arithmetic: Snta Oeration Descrition b Eamle *++ *(++) (*)++ Post-Increment Pointer Post-Increment data ointed to b Pointer z = *(++); is equivalent to: z = *; = + 1; z = (*)++; is equivalent to: z = *; * = * + 1; Eamle int [3] = 1,2,3; int ; int * = &; = 5 + *(++); = 5 + (*)++; *(++)is the same as*

11 Post-Increment / Decrement Snta Post-Increment / Decrement Snta Eamle Eamle int [3] = 1,2,3; int ; int * = &; int [3] = 1,2,3; int ; int * = &; = 5 + *(++); = 5 + *(++); = 5 + (*)++; = 5 + (*)++; 0006 *(++)is the same as*++ *(++)is the same as*++ Post-Increment / Decrement Snta Post-Increment / Decrement Snta Eamle Eamle int [3] = 1,2,3; int ; int * = &; int [3] = 1,2,3; int ; int * = &; = 5 + *(++); = 5 + *(++); = 5 + (*)++; 0007 = 5 + (*)++; 0007 *(++)is the same as*++ *(++)is the same as*++ 11

12 Pre-Increment/Decrement Snta Rule Pre-Increment / Decrement Snta Care must be taken with resect to oerator recedence when doing ointer arithmetic: Snta Oeration Descrition b Eamle ++* *(++) ++(*) Pre-Increment Pointer Pre-Increment data ointed to b Pointer z = *(++); is equivalent to: = + 1; z = *; z = ++(*); is equivalent to: * = * + 1; z = *; Eamle int [3] = 1,2,3; int ; int * = &; = 5 + *(++); = (*); *(++)is the same as* Pre-Increment / Decrement Snta Pre-Increment / Decrement Snta Eamle Eamle int [3] = 1,2,3; int ; int * = &; int [3] = 1,2,3; int ; int * = &; = 5 + *(++); = 5 + *(++); = (*); = (*); 0007 *(++)is the same as*++ *(++)is the same as*++ 12

Pre-Increment / Decrement Snta Pre-Increment / Decrement Snta Eamle Eamle int [3] = 1,2,3; int ; int * = &; int [3] = 1,2,3; int ; int * = &; = 5 + *(++); = 5 + *(++); = 5 + ++(*); 0007 = 5 + ++(*);

13 Pre-Increment / Decrement Snta Pre-Increment / Decrement Snta Eamle Eamle int [3] = 1,2,3; int ; int * = &; int [3] = 1,2,3; int ; int * = &; = 5 + *(++); = 5 + *(++); = (*); 0007 = (*); 0008 *(++)is the same as*++ *(++)is the same as*++ Pre- and Post- Increment/Decrement Summar The arentheses determine what gets incremented/decremented: Modif the ointer itself *(++)or *++and *(++)or *++ Initialization Ti If a ointer isn't initialized to a secific address when it is created, it is a good idea to initialize it as NUL (ointing to nowhere) This will revent it from unintentionall corruting a memor location if it is accidentall used before it is initialized Modif the value ointed to b the ointer ++(*)and (*)++ Eamle int * = NULL; NULis the character '\0'but NULLis the value of a ointer that oints to nowhere 13

14 Eercise 11 and Pointer Arithmetic Oen the lab Project: Lab 11 and On the class website /Eamles/Lab11.zi -> Load Lab11.X 1 Oen MPLAB X and select Oen Project Icon (Ctrl + Shift + O) Oen the Project listed above. If ou alread have a roject oen in MPLAB X, close it b right clicking on the oen roject and selecting Close Eercise 11 and Solution: Stes 1, 2 and 3 /*############################################################################ # STEP 1: Initialize the ointer with the address of the variable ############################################################################*/ //Point to address of = &; /*############################################################################ # STEP 2: Comlete the following rintf() functions b adding in the # aroriate arguments as described in the control string. ############################################################################*/ rintf("the variable is located at address 0%X\n", &); rintf("the value of is %d\n", ); rintf("the ointer is located at address 0%X\n", &); rintf("the value of is 0%X\n", ); rintf("the value ointed to b * = %d\n", *); /*############################################################################ # STEP 3: Write the int value 10 to the location is currentl ointing to. ############################################################################*/ * = 10; Eercise 11 and Solution: Stes 4 and 5 /*############################################################################ # STEP 4: Increment the value that oints to. ############################################################################*/ //Increment arra element's value (*)++; rintf("[%d] = %d\n", i, *); /*############################################################################ # STEP 5: Increment the ointer so that it oints to the net item. ############################################################################*/ //Increment ointer to net arra element ++; 14

15 Eercise 11 Conclusions are variables that hold the address of other variables make it ossible for the rogram to change which variable is acted on b a articular line of code Incrementing and decrementing ointers will modif the value in multiles of the size of the te the oint to Questions? 15

16 16

17 17

18 18

19 19

Gabriel Hugh Elkaim Spring CMPE 013/L: C Programming. CMPE 013/L: C Programming

Gabriel Hugh Elkaim Spring CMPE 013/L: C Programming. CMPE 013/L: C Programming 1 CMPE 013/L Gabriel Hugh Elkaim Sring 2013 2 A Variable's versus A Variable's Value In some situations, we will want to work with a variable's address in memor, rather than the value it contains Variable