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

Size: px

Start display at page:

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

Kerry Griffin
6 years ago
Views:

1 1

2 CMPE 013/L Gabriel Hugh Elkaim Sring

3 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 stored at Variable name from C code int x; Value of variable x = 0x0123 x 005A 0123 DEAD BEEF F00D 0456 of variable x = What are ointers? A ointer is a variable or constant that holds the address of another variable or function Variable at Integer Variable: Pointer Variable: x FFFF 0123 FFFF 0802 FFFF FFFF 3

4 What do the do? A ointer allows us to indirectl access a variable (just like indirect addressing in assembl language) Direct Access via x x = 0x0123; * = 0x0123; Indirect Access via * 005A x 0123 DEAD 0802 F00D 0456 oints to x 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. : 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 next available bte in RAM buffer bufptr++; 4

5 Wh would I want to do that? : 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 next address in buffer (4) Reeat until data from UART is 0, or buffer is full (arrow oints to last address of buffer) AB CDEF BDF ACE 0x08BA 0x08BC 0x08BE 0x08C0 0x08C2 0x08C4 0x08C6 0x08C8 Where else are the used? Used in conjunction with dnamic memor allocation (creating variables at runtime) Provide method to ass arguments b reference to 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 5

6 Sntax te *trname; How to Create a Pointer Variable In the context of a declaration, the * merel indicates that the variable is a ointer te is the te of data the ointer ma oint to Pointer usuall described as a ointer to te int *iptr; float *fptr; // Create a ointer to int // Create a ointer to float Sntax How to Create a Pointer Te with tedef tedef te *tename; A ointer variable can now be declared as te tename which is a snonm for te The * is no longer needed since tename exlicitl 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 6

7 To set a ointer to oint to another variable, we use the & oerator (address of), and the ointer variable is used without the dereference oerator *: This assigns the address of the variable x to the ointer ( now oints to x) Note: must be declared to oint to the te of x (e.g. int x; int *;) Initialization = &x; Usage When accessing the variable ointed to b a ointer, we use the ointer with the dereference oerator *: = *; This assigns to the variable, the value of what is ointing to (x from the last slide) Using *, is the same as using the variable it oints to (e.g. x) 7

8 Another Wa To Look At The Sntax int x, *; //int and a ointer to int = &x; //Assign the address of x * = 5; //Same as x = 5; &xis a constant ointer It reresents the address of x The address of x will never change is a variable ointer to int It can be assigned the address of an int It ma be assigned a new address an time Another Wa To Look At The Sntax int x, *; //1 int, 1 ointer to int = &x; //Assign the address of x * = 5; //Same as x = 5; *reresents the data ointed to b *ma be used anwhere ou would use x *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 8

9 Contents of Letter (integer literal 5) Another Wa To Look At The Sntax * = 5; Contents of the Mailbox (variable x or *) of Mailbox (&x) 105 on Enveloe (ointer ) = &x; Bank of Mailboxes (memor locations) How Work int x, ; int *; Variable at 0x08BA x = 0xDEAD; = 0xBEEF; = &x; * = 0x0100; = &; * = 0x0200; x 0x08BC 0x08BE 0x08C0 0x08C2 0x08C4 0x08C6 0x08C8 9

10 How Work int x, ; int *; Variable at 0x08BA x = 0xDEAD; = 0xBEEF; = &x; * = 0x0100; = &; * = 0x0200; x DEAD 0x08BC 0x08BE 0x08C0 0x08C2 0x08C4 0x08C6 0x08C8 How Work int x, ; int *; Variable at 0x08BA x = 0xDEAD; = 0xBEEF; = &x; * = 0x0100; = &; * = 0x0200; x DEAD BEEF 0x08BC 0x08BE 0x08C0 0x08C2 0x08C4 0x08C6 0x08C8 10

11 How Work int x, ; int *; Variable at 0x08BA x = 0xDEAD; = 0xBEEF; = &x; * = 0x0100; = &; * = 0x0200; x DEAD BEEF 08BC 0x08BC 0x08BE 0x08C0 0x08C2 0x08C4 0x08C6 0x08C8 How Work int x, ; int *; Variable at 0x08BA x = 0xDEAD; = 0xBEEF; = &x; * = 0x0100; = &; * = 0x0200; x 0100 BEEF 08BC 0x08BC 0x08BE 0x08C0 0x08C2 0x08C4 0x08C6 0x08C8 11

12 How Work int x, ; int *; Variable at 0x08BA x = 0xDEAD; = 0xBEEF; = &x; * = 0x0100; = &; * = 0x0200; x 0100 BEEF 08BE 0x08BC 0x08BE 0x08C0 0x08C2 0x08C4 0x08C6 0x08C8 How Work int x, ; int *; Variable at 0x08BA x = 0xDEAD; = 0xBEEF; = &x; * = 0x0100; = &; * = 0x0200; x BE 0x08BC 0x08BE 0x08C0 0x08C2 0x08C4 0x08C6 0x08C8 12

13 and Arras A Quick Reminder Arra elements occu consecutive memor locations int x[3] = 1,2,3; FFFF FFFF 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 x[5] = 1,2,3,4,5; int *; We can initialize the ointer to oint to the arra using an one of these three methods: = x; = &x; = &; //Works onl for arras! //Works for arras or variables //This one is the most obvious 13

14 and Arras A Preview of Pointer Arithmetic Incrementing a ointer will move it to the next element of the arra int x[3] = 1,2,3; int *; = &x; ++; FFFF FFFF More on this in just a bit and Arras A Preview of Pointer Arithmetic Incrementing a ointer will move it to the next element of the arra int x[3] = 1,2,3; int *; = &x; ++; FFFF More on this in just a bit 14

15 and Arras A Preview of Pointer Arithmetic Incrementing a ointer will move it to the next element of the arra int x[3] = 1,2,3; int *; = &x; ++; FFFF More on this in just a bit Pointer Arithmetic Incrementing Incrementing or decrementing a ointer will add or subtract a multile of the number of btes of its te If we have: float x; float * = &x; ++; We will get = &x + 4 since a float variable occuies 4 btes of memor 15

16 Pointer Arithmetic Incrementing float *tr; tr = &a; tr++; Incrementing tr moves it to the next 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] 0x0050 0x0052 0x0054 0x0056 0x0058 0x005A 0x005C 0x005E 0x0060 0x0062 0x0064 0x0066 0x0068 0x006A 0x006C 0x006E 0x0070 0x0072 0x0074 0x0076 Pointer Arithmetic 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 x; int * = &x; += 3; We will get = &x + 6 since an int variable occuies 2 btes of memor 16

17 Pointer Arithmetic Larger Jums float *tr; tr = &a; Adding 6 to tr moves it 6 float arra 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] 0x0050 0x0052 0x0054 0x0056 0x0058 0x005A 0x005C 0x005E 0x0060 0x0062 0x0064 0x0066 0x0068 0x006A 0x006C 0x006E 0x0070 0x0072 0x0074 0x0076 Pointer Arithmetic long x[3] = 1,2,3; long * = &x; * += 4; ++; * = 0xDEADBEEF; ++; * = 0xF1D0F00D; -= 2; * = 0xBADF00D1;

18 Pointer Arithmetic long x[3] = 1,2,3; long * = &x; * += 4; ++; * = 0xDEADBEEF; ++; * = 0xF1D0F00D; -= 2; * = 0xBADF00D1; Pointer Arithmetic long x[3] = 1,2,3; long * = &x; * += 4; ++; * = 0xDEADBEEF; ++; * = 0xF1D0F00D; -= 2; * = 0xBADF00D1;

19 Pointer Arithmetic long x[3] = 1,2,3; long * = &x; * += 4; ++; * = 0xDEADBEEF; ++; * = 0xF1D0F00D; -= 2; * = 0xBADF00D1; 0005 BEEF DEAD 0804 Pointer Arithmetic long x[3] = 1,2,3; long * = &x; * += 4; ++; * = 0xDEADBEEF; ++; * = 0xF1D0F00D; -= 2; * = 0xBADF00D1; 0005 BEEF DEAD

20 Pointer Arithmetic long x[3] = 1,2,3; long * = &x; * += 4; ++; * = 0xDEADBEEF; ++; * = 0xF1D0F00D; -= 2; * = 0xBADF00D1; 0005 BEEF DEAD F00D F1D Pointer Arithmetic long x[3] = 1,2,3; long * = &x; * += 4; ++; * = 0xDEADBEEF; ++; * = 0xF1D0F00D; -= 2; * = 0xBADF00D1; 0005 BEEF DEAD F00D F1D

21 Pointer Arithmetic long x[3] = 1,2,3; long * = &x; * += 4; ++; * = 0xDEADBEEF; ++; * = 0xF1D0F00D; -= 2; * = 0xBADF00D1; 00D1 BADF BEEF DEAD F00D F1D Post Increment/Decrement Sntax Rule Care must be taken with resect to oerator recedence when doing ointer arithmetic: Sntax Oeration Descrition b *++ *(++) (*)++ Post Increment Pointer Post Increment data ointed to b Pointer z = *(++); is equivalent to: z = *; = + 1; z = (*)++; is equivalent to: z = *; * = * + 1; 21

22 Post Increment / Decrement Sntax int x[3] = 1,2,3; int ; int * = &x; = 5 + *(++); = 5 + (*)++; Remember: *(++) is the same as * Post Increment / Decrement Sntax int x[3] = 1,2,3; int ; int * = &x; = 5 + *(++); = 5 + (*)++; Remember: *(++) is the same as *

23 Post Increment / Decrement Sntax int x[3] = 1,2,3; int ; int * = &x; = 5 + *(++); = 5 + (*)++; Remember: *(++) is the same as * Post Increment / Decrement Sntax int x[3] = 1,2,3; int ; int * = &x; = 5 + *(++); = 5 + (*)++; Remember: *(++) is the same as *

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

25 Pre Increment / Decrement Sntax int x[3] = 1,2,3; int ; int * = &x; = 5 + *(++); = (*); Remember: *(++) is the same as * Pre Increment / Decrement Sntax int x[3] = 1,2,3; int ; int * = &x; = 5 + *(++); = (*); Remember: *(++) is the same as *

26 Pre Increment / Decrement Sntax int x[3] = 1,2,3; int ; int * = &x; = 5 + *(++); = (*); Remember: *(++) is the same as * Pre Increment / Decrement Sntax int x[3] = 1,2,3; int ; int * = &x; = 5 + *(++); = (*); Remember: *(++) is the same as *

27 Pre Increment / Decrement Sntax int x[3] = 1,2,3; int ; int * = &x; = 5 + *(++); = (*); Remember: *(++) is the same as * The arentheses determine what gets incremented/decremented: Modif the ointer itself Pre and Post Increment/Decrement Summar *(++) or *++ and *(++) or *++ Modif the value ointed to b the ointer ++(*) and (*)++ 27

28 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 int * = NULL; NUL is the character '\0' but NULL is the value of a ointer that oints to nowhere Exercise 11 and Pointer Arithmetic 28

Oen the lab Project: Lab 11 and Pointer Arithmetic On the class website /s/lab11.zi > Load Lab11.X 1 Oen MPLAB X and select Oen Project Icon (Ctrl + Shift + O) Oen the Project listed above.

29 Oen the lab Project: Lab 11 and Pointer Arithmetic On the class website /s/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 Exercise 11 and Pointer Arithmetic Solution: Stes 1, 2 and 3 /*############################################################################ # STEP 1: Initialize the ointer with the address of the variable x ############################################################################*/ //Point to address of x = &x; /*############################################################################ # STEP 2: Comlete the following rintf() functions b adding in the # aroriate arguments as described in the control string. ############################################################################*/ rintf("the variable x is located at address 0x%X\n", &x); rintf("the value of x is %d\n", x); rintf("the ointer is located at address 0x%X\n", &); rintf("the value of is 0x%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; 29

30 Exercise 11 and Pointer Arithmetic 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 next item. ############################################################################*/ //Increment ointer to next arra element ++; Exercise 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 30

31 Questions? 31

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

Pointers CMPE-013/L. Pointers. Pointers What do they do? Pointers What are pointers? Gabriel Hugh Elkaim Winter 2014 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