Binghamton University. CS-211 Fall Pointers

Size: px

Start display at page:

Download "Binghamton University. CS-211 Fall Pointers"

Neal Bennett
6 years ago
Views:

1 Pointers 1

2 Memory The act of keeping track of something over time Remembering is the concept of storing information A memory is no good unless you can retrieve that information In a computer, we remember information by writing bits (1/0) to memory We retrieve information by reading bits from memory

short-term memory Reading and Writing memory is much faster

3 Memory is Different from Disk Storage All values in memory are forgotten when power is turned off Memory is really short-term memory Reading and Writing memory is much faster than reading or writing disk Memory is organized differently than disk

4 Computer Memory Organization Computers read and write memory in 1 byte (8 bit) chunks Think of memory as a big C vector of chars: char memory[2_142_240_768]; Like a vector, if we know the index of a byte of memory, we can either read or write to that byte: memory[1_684_501_289] = A ; printf( We stored %c\n,memory[1_684_501_289];

5 What is a pointer? Index into the memory vector Says I m not important what s important is over there Points AT or TO the real data in memory 5

6 Memory Vector of bytes Each byte has a value Each byte has an index or address Usually, the address is specified in hexadecimal xffff fffd xffff fffe xffff ffff x00 x04 x1c x02 x96 x00 x30 x04 6

7 Cheap Memory Between Moore s Law and brilliant OS parlor tricks, Virtual Memory is VERY cheap! Memory size depends on the size of the address Address Size Number of Bytes addressable 2 bytes (16 bits) 2 16 = 64K = 65,376 4 bytes (32 bits) 2 32 = 4G = 4,284,481,536 8 bytes (64 bits) 2 64 = 16EiB >1.8 x 10 19

8 C Variables A variable is a named piece of data Variables in C have A name (specified by the programmer) A value (may be unassigned/unknown) A location in memory (determined by the compiler) A type (size and interpretation) Variables must be declared before they are used! 8

9 Variable Concept Age Memory???????????????????????????????????????????????????????????????????????? First_Initial gpa 9

10 Variables In Memory Every variable starts at a specific location (address) in memory Type of variable tells how many bytes in memory First_Initial age x0034 ffe0 x004d 18c4 xffff fffd xffff fffe xffff ffff x00 x04 x1c x02 x54 x00 x00 x00 x39 x96 x00 x30 x04 10

11 Variable Address/Location Where is the value for the variable in memory? The address of First_Initial is x0034ffe0, which points to 0x54 = T First_Initial age x0034 ffe0 x004d 18c4 xffff fffd xffff fffe xffff ffff x00 x04 x1c x02 x54 x00 x00 x00 x39 x96 x00 x30 x04 11

12 Variable Address/Location Where is the value for the variable in memory? The address of age is x004d18c4, which points to the integer (4 byte) value 0x =57 age First_Initial x0034 ffe0 x004d 18c4 xffff fffd xffff fffe xffff ffff x00 x04 x1c x02 x54 x00 x00 x00 x39 x96 x00 x30 x04 12

13 Address Of (&) operator An ampersand (&) in front of a variable indicates address of char First_Initial= T ; int age=57; printf( First_Initial is in memory at %p\n,&first_initial); First_Initial is in memory at 0x34ffe0 First_Initial age x00 x04 x1c x02 x54 x00 x00 x00 x39 x96 x00 x30 x x0034 ffe0 x004d 18c4 xffff fffd xffff fffe xffff 13 ffff

14 Pointers in C Pointers are a special class of data type A variable may be declared as a pointer The size of a pointer is the size of an address The VALUE of a pointer is an address The TYPE of a pointer includes the type of value it is pointing to! pointer to character pointer to integer pointer to float pointer to struct date 14

15 Declaring a Pointer Same as normal variable but need asterisk (*) : pointer to char First_Initial= T ; char * fi_ptr; // pointer to char fi_ptr=&first_initial; // must be the address of char! printf( Value of fi_ptr is %p\n,fi_ptr); Value of fi_ptr is 0x34ffe0 First_Initial fi_ptr x00 x04 x1c x02 x54 x00 x34 xff xe0 x96 x00 x30 x x0034 ffe0 x004d 18c4 xffff fffd xffff fffe xffff 15 ffff

16 Pointers as References A pointer has a value an address in memory A pointer points to another value the data at that address Because we know what type the pointer is pointing to, we know how long the data at that address should be fi_ptr First_Initial 0x0034ffe0 x54 16

17 Using a Pointer Same as normal variable but need asterisk (*) : value at char First_Initial= T ; char * fi_ptr=&first_initial; // pointer to char printf( fi_ptr points at %c\n, (*fi_ptr) ); fi_ptr points at T First_Initial fi_ptr x00 x04 x1c x02 x54 x00 x34 xff xe0 x96 x00 x30 x x0034 ffe0 x004d 18c4 xffff fffd xffff fffe xffff 17 ffff

18 Terminology fi_ptr references First_Initial char First_Initial= T ; char * fi_ptr=&first_initial; // pointer to char printf( fi_ptr points at %c\n, (*fi_ptr) ); fi_ptr points at T *fi_ptr dereferences fi_ptr First_Initial fi_ptr x00 x04 x1c x02 x54 x00 x34 xff xe0 x96 x00 x30 x x0034 ffe0 x004d 18c4 xffff fffd xffff fffe xffff 18 ffff

19 Abuse of Symbols Ampersand (&) x & y // Bit-wise AND x && y // Logical AND &x // Address Of Asterix (*) x * y // multiplication int * x // pointer to (*x) // value at 19

20 Pointers as Aliases char First_Initial= T ; char * fi_ptr=&first_initial; (*fi_ptr)= A ; // Alias for First_Initial printf( First Initial: %c\n,first_initial); First_Initial *fi_ptr First Initial: A x54 20

21 Using NULL NULL is a special address whose value is 0x Beginning of Memory belongs to the operating system General programs can read at 0, but cannot write at 0 Therefore, we use NULL to indicate pointer to nothing Or pointer that we haven t set yet int *p=null; // p is a pointer to nothing (for now) p=&age; // Now p is a pointer to an integer 21

22 C Gotcha: Dereferencing a Null Pointer int *p=null; // p is a pointer to nothing (for now) int x=foo(); if (x>0) { p=&x; } (*p) = 5; Segmentation Violation when x<=0

23 Pointers point to Types int *x; // x is a pointer to an integer &z Type is: pointer to <type of z> (*myptr) Type is: type which myptr is pointing to e.g. int *myptr=&area; (*myptr)= a ; assigning char to int ASCII value of a is 0x61 area is now 0x

24 Void Pointers void * myptr; // myptr is a pointer to void myptr is a pointer, but I m not going to tell you what it points at Before you use myptr, you must cast it as a pointer to something printf( myptr points to %c\n,*(char *)myptr); void * used as a universal pointer a pointer to any type of data Programmer must know what type of data it s pointing at to cast correctly 24

25 The Power of Pointers Pointers are a Reference to what they are pointing at Rather than passing an entire <type> element, we can pass a pointer to that type. (Pointers are 8 bytes long.) Rather than passing an int, pass a pointer to an int Rather than passing a struct, pass a pointer to that struct Rather than passing an array, pass a pointer to that array If we pass a reference, then we can modify what we are pointing to, EVEN IF THE REFERENCE ITSELF IS A COPY!

26 Example of Pass by Reference int counter=0; void incr(int x) { x = x + 1; } incr(counter); printf( counter=%d\n,counter); int counter=0; void incr(int *x) { (*x) = (*x) + 1; } incr(&counter); printf( counter=%d\n,counter); counter=0 counter=1

27 Pointers to Structures It is so useful to pass structures by reference, we almost always do so C programmers got tired of coding: (*todayref).year Pointer to structure shorthand (*todayref).year is the same as. todayref->year

28 Pointers vs. Arrays 28

29 Array Values are Contiguous Right next to each other in memory int vec[6] int m [4][3]; vec[0] vec[1] vec[2] vec[3] vec[4] vec[5] m[0][0] m[0][1] m[0][2] m[1][0] m[1][1] m[1][2] m[2][0] m[2][1] m[2][2] m[3][0] m[3][1] m[3][2] 29

30 Example Array in Memory char name[8]= Thomas ; printf( name is at %p\n,&name[0]); name is at 0x34ffe0 name x00 x04 x1c x02 x54 x68 x6f x6d x61 x73 x00 x00 x96 x00 x30 x04 x0034 ffe x0034 ffe0 xffff fffd xffff fffe xffff 30 ffff

31 Pointer to Array in Memory char name[8]= Thomas ; char *np=&name[0]; printf( np is %p\n,np); np is at 0x34ffe0 name np x00 x04 x1c x02 x54 x68 x6f x6d x61 x73 x00 x00 x96 x00 x30 x04 x0034 ffe x0034 ffe0 xffff fffd xffff fffe xffff 31 ffff

32 What are we Pointing At? char name[8]= Thomas ; char *np=&name[0]; printf( np -> %c\n,(*np)); Question: Does np point to a single character? np -> T name np x00 x04 x1c x02 x54 x68 x6f x6d x61 x73 x00 x00 x96 x00 x30 x04 x0034 ffe x0034 ffe0 xffff fffd xffff fffe xffff 32 ffff

33 Pointers are just numbers char name[8]= Thomas ; char *np=&name[0]; printf( np=%x np+1=%x np+2=%x,np,np+1,np+2); np=x34ffeo np+1=x34ffe1 np+2=x34ffe2 name np x00 x04 x1c x02 x54 x68 x6f x6d x61 x73 x00 x00 x96 x00 x30 x04 x0034 ffe x0034 ffe0 xffff fffd xffff fffe xffff 33 ffff

34 What are we Pointing At? char name[8]= Thomas ; char *np=&name[0]; printf( np ->%c-%c-%c \n,*np,*(np+1),*(np+2)); np -> T-h-o name np Question: Does np point to a single character? Or an array of characters? x00 x04 x1c x02 x54 x68 x6f x6d x61 x73 x00 x00 x96 x00 x30 x04 x0034 ffe x0034 ffe0 xffff fffd xffff fffe xffff 34 ffff

35 What is a string? A string is just a vector of ASCII characters Followed by a null terminator a byte with the value 0x00 char str[14]= This a string ; { T, h, i, s,, a,, s, t, r, i, n, g, x00} Index ASCII T h i s a s t r i n g Hex x54 x68 x69 x73 x20 x61 x20 x73 x74 x72 x69 x6e x67 x00 35

36 What are we Pointing At? char name[8]= Thomas ; char *np=&name[0]; printf( np ->%s\n,np); np -> Thomas Question: Does np point to a single character? Or an array of characters? Or a string? name np x00 x04 x1c x02 x54 x68 x6f x6d x61 x73 x00 x00 x96 x00 x30 x04 x0034 ffe x0034 ffe0 xffff fffd xffff fffe xffff 36 ffff

37 A Pointer points to one or more elements of a specific type (Actually, zero or more, but who s counting) 37

38 Integer Vector in Memory int v[4]={11,12,13,14}; Vector v[0] v[1] v[2] v[3] Value x B x C x D x E Address x00 c x00 c x00 c0 00 1c x00 c int *vp=&v[0]; // vp=x00c printf( vp-> %d %d %d \n,*vp,*(vp+1),*(vp+2)); vp->

39 Pointer Arithmetic In C, if we add 1 to a pointer, that means, point to the next element If char * ptr points to a character, then ptr+1 points to the next character If int * iptr points to an integer, then iptr+1 points to the next integer If float *aptr[4] points to an array of 4 floats, then aptr+1 points to the next array of 4 floats. 39

40 Pointer Arithmetic In order to make this work, C uses funny arithmetic on pointers If char * ptr points to a character, printf( char@ %x, next char@ %x\n,ptr,ptr+1); prints: char@ 34ffe0 next 34ffe1 If int * iptr points to an integer, printf( %x next %x\n,iptr,iptr+1); prints: c00014 next c00018 If float *aptr[4] points to an array of 4 floats, printf( %x next %x\n,aptr,aptr+1); prints: a461a20 next a461a30 40

41 2D Arrays in Memory int m[4][3]={11,12,13,21,22,23,31,32,33,41,42,43}; m[0][0] m[0][1] m[0][2] m[1][0] m[1][1] m[1][2] m[2][0] m[2][1] m[2][2] m[3][0] m[3][1] m[3][2] c c c0 001c c c c c0 002c c c c c0 003c c int *mp=&m[0][0]; // mp=x00c printf( mp-> %d %d %d \n,*mp,*(mp+1),*(mp+2)); printf( row 3: %d %d %d\n,*(mp+6),*(mp+7),*(mp+8)); mp-> row 3:

42 What is an un-sub-scripted Array? char name[8]= Thomas ; printf( name[0] is at %p\n,&name[0]); printf( name value is %x\n,name); name[0] is at 0x23cb10 name value is 23cb10 42

43 array == &array[0] 43

44 What is a String? char name[8]= Thomas ; printf( name[0] is at %p\n,&name[0]); printf( name value is %x\n,name); printf( name string is %s\n,name); name[0] is at 0x23cb10 name value is 23cb10 name string is Thomas 44

45 A string is a pointer to one or more characters 45

46 What is a String? char *name= Thomas ; printf( name[0] is at %p\n,&name[0]); printf( name value is %x\n,name); printf( name string is %s\n,name); name[0] is at 0x23cb10 name value is 23cb10 name string is Thomas 46

47 In C, Pointers and Arrays are Virtually Interchangeable! 47

48 Array vs. Pointer Notation Array &array[0] array[i] Pointer array *(array+i) 48

49 strlen implementations Using array notation int strlen(char str[]) { } int i=0; while(str[i]!=x00) i++; return i; Using pointer notation int strlen(char *str) { } int i=0; while((*str)!=0) { } return i; i++; str++; 49

50 Pointers and Memory When you declare an int or array of ints, the compiler reserves memory for that int or array of ints in the invocation record When you declare a pointer to an int or array of ints, the compiler reserves memory for the POINTER, but does NOT reserve memory for the actual data being pointed to! Typical C bug: int char* name; strcpy(name, Tom Bartenstein ); Segmentation Violation

51 Initialized Pointers In some cases, it looks like pointers ARE reserving memory char * name = Tom Bartenstein ; In this case, the compiler is creating a LITERAL value in memory Possibly read only memory Possibly re-used with other instances of Tom Bartenstein in this code The name variable is a pointer to the LITERAL value May get segmentation violation if written to May get bizarre future errors if compiler re-used this literal

52 Resources Programming in C, Chapter 10 Wikepedia Pointers : C Pointer Tutorial : 52

Binghamton University. CS-211 Fall Pointers vs. Arrays

Binghamton University. CS-211 Fall Pointers vs. Arrays Pointers vs. Arrays 1 Array Values are Contiguous Right next to each other in memory int vec[6] int m [4][3]; vec[0] vec[1] vec[2] vec[3] vec[4] vec[5] m[0][0] m[0][1] m[0][2] m[1][0] m[1][1] m[1][2] m[2][0]