CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine...
-
date post
22-Dec-2015 -
Category
Documents
-
view
220 -
download
5
Transcript of CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine...
![Page 1: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/1.jpg)
CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB
inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures
Lecture #3: C Pointers & Arrays
2006-06-28
Andy Carle
![Page 2: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/2.jpg)
CS 61C L03 C Arrays (2) A Carle, Summer 2006 © UCB
Address vs. Value•What good is a bunch of memory if you can’t select parts of it?
• Each memory cell has an address associated with it.
• Each cell also stores some value.
•Don’t confuse the address referring to a memory location with the value stored in that location.
23 42 ... ...101 102 103 104 105 ...
![Page 3: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/3.jpg)
CS 61C L03 C Arrays (3) A Carle, Summer 2006 © UCB
Pointers•A pointer is just a C variable whose value is the address of another variable!
•After declaring a pointer:int *ptr;
ptr doesn’t actually point to anything yet. We can either:
• make it point to something that already exists, or
• allocate room in memory for something new that it will point to… (next time)
![Page 4: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/4.jpg)
CS 61C L03 C Arrays (4) A Carle, Summer 2006 © UCB
Pointers•Declaring a pointer just allocates space to hold the pointer – it does not allocate something to be pointed to!
•Local variables in C are not initialized, they may contain anything.
![Page 5: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/5.jpg)
CS 61C L03 C Arrays (5) A Carle, Summer 2006 © UCB
Pointer Usage Example
Memory and Pointers:0xffff ffff
0x0000 0000
0xcafe 0000
0xbeef 0000
0x0000 0004
![Page 6: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/6.jpg)
CS 61C L03 C Arrays (6) A Carle, Summer 2006 © UCB
Pointer Usage Example
Memory and Pointers:
int *p, v;
0xXXXXXXXX
0xffff ffff
0x0000 0000
0xcafe 0000
0xXXXXXXXX 0xbeef 0000
0x0000 0004
p:
v:
![Page 7: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/7.jpg)
CS 61C L03 C Arrays (7) A Carle, Summer 2006 © UCB
Pointer Usage Example
Memory and Pointers:
int *p, v;
p = &v;0xXXXXXXXX
0xffff ffff
0x0000 0000
0xcafe 0000
0xcafe 0000 0xbeef 0000
0x0000 0004
p:
v:
![Page 8: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/8.jpg)
CS 61C L03 C Arrays (8) A Carle, Summer 2006 © UCB
Pointer Usage Example
Memory and Pointers:
int *p, v;
p = &v;
v = 0x17;
0x0000 0017
0xffff ffff
0x0000 0000
0xcafe 0000
0xcafe 0000 0xbeef 0000
0x0000 0004
p:
v:
![Page 9: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/9.jpg)
CS 61C L03 C Arrays (9) A Carle, Summer 2006 © UCB
Pointer Usage Example
Memory and Pointers:
int *p, v;
p = &v;
v = 0x17;
*p = *p + 4;
V = *p + 4
0x0000 001b
0xffff ffff
0x0000 0000
0xcafe 0000
0xcafe 0000 0xbeef 0000
0x0000 0004
p:
v:
![Page 10: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/10.jpg)
CS 61C L03 C Arrays (10) A Carle, Summer 2006 © UCB
Pointers in C•Why use pointers?
• If we want to pass a huge struct or array, it’s easier to pass a pointer than the whole thing.
• In general, pointers allow cleaner, more compact code.
•So what are the drawbacks?• Pointers are probably the single largest source of bugs in software, so be careful anytime you deal with them.
• Dangling reference (premature free)
• Memory leaks (tardy free)
![Page 11: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/11.jpg)
CS 61C L03 C Arrays (11) A Carle, Summer 2006 © UCB
C Pointer Dangers•What does the following code do?
• S E G F A U L T ! (on my machine/os)• (Not a nice compiler error like you would hope!)
void f(){ int *ptr; *ptr = 5;}
![Page 12: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/12.jpg)
CS 61C L03 C Arrays (12) A Carle, Summer 2006 © UCB
C Pointer Dangers•Unlike Java, C lets you cast a value of any type to any other type without performing any checking.
int x = 1000;
int *p = x; /* invalid */
int *q = (int *) x; /* valid */
•The first pointer declaration is invalid since the types do not match.
•The second declaration is valid C but is almost certainly wrong
• Is it ever correct?
![Page 13: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/13.jpg)
CS 61C L03 C Arrays (13) A Carle, Summer 2006 © UCB
Pointers and Parameter Passing•Java and C pass a parameter “by value”
• procedure/function gets a copy of the parameter, so changing the copy cannot change the original
void addOne (int x) { x = x + 1;
}
int y = 3;
addOne(y);
•y is still = 3
![Page 14: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/14.jpg)
CS 61C L03 C Arrays (14) A Carle, Summer 2006 © UCB
Pointers and Parameter Passing•How to get a function to change a value? void addOne (int *p) {
*p = *p + 1;}
int y = 3;
addOne(&y);
•y is now = 4
![Page 15: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/15.jpg)
CS 61C L03 C Arrays (15) A Carle, Summer 2006 © UCB
Administrivia
•Office Hours for either GSI?
![Page 16: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/16.jpg)
CS 61C L03 C Arrays (16) A Carle, Summer 2006 © UCB
Arrays (1/7)•Declaration:
int ar[2];
declares a 2-element integer array.
int ar[] = {795, 635};
declares and fills a 2-elt integer array.
•Accessing elements:
ar[num];
returns the numth element from 0.
![Page 17: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/17.jpg)
CS 61C L03 C Arrays (17) A Carle, Summer 2006 © UCB
Arrays (2/7)•Arrays are (almost) identical to pointers•char *string and char string[] are nearly identical declarations
• They differ in very subtle ways: incrementing, declaration of filled arrays
•Key Difference:
An array variable is a CONSTANT pointer to the first element.
![Page 18: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/18.jpg)
CS 61C L03 C Arrays (18) A Carle, Summer 2006 © UCB
Arrays (3/7)•Consequences:
•ar is a pointer•ar[0] is the same as *ar•ar[2] is the same as *(ar+2)
• We can use pointer arithmetic to access arrays more conveniently.
•Declared arrays are only allocated while the scope is valid
char *foo() { char string[32]; ...; return string;} is incorrect
![Page 19: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/19.jpg)
CS 61C L03 C Arrays (19) A Carle, Summer 2006 © UCB
Arrays (4/7)•Array size n; want to access from 0 to n-1:
int ar[10], i=0, sum = 0;...while (i < 10) /* sum = sum+ar[i];
i = i + 1; */
sum += ar[i++];
![Page 20: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/20.jpg)
CS 61C L03 C Arrays (20) A Carle, Summer 2006 © UCB
Arrays (5/7)•Array size n; want to access from 0 to n-1, so you should use counter AND utilize a constant for declaration & incr
• Wrongint i, ar[10];for(i = 0; i < 10; i++){ ... }
• Right #define ARRAY_SIZE 10int i, a[ARRAY_SIZE];for(i = 0; i < ARRAY_SIZE; i++){ ... }
•Why? SINGLE SOURCE OF TRUTH• You’re utilizing indirection and avoiding maintaining two copies of the number 10
![Page 21: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/21.jpg)
CS 61C L03 C Arrays (21) A Carle, Summer 2006 © UCB
Arrays (6/7)•Pitfall: An array in C does not know its own length, & bounds not checked!
• Consequence: We can accidentally access off the end of an array.
• Consequence: We must pass the array and its size to a procedure which is going to traverse it.
•Segmentation faults and bus errors:• These are VERY difficult to find; be careful!
• You’ll learn how to debug these in lab…
![Page 22: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/22.jpg)
CS 61C L03 C Arrays (22) A Carle, Summer 2006 © UCB
Arrays 7/7: In Functions•An array parameter can be declared as an array or a pointer; an array argument can be passed as a pointer.
• Can be incremented
int strlen(char s[]){ int n = 0; while (s[n] != 0) n++; return n;}
int strlen(char *s){ int n = 0; while (s[n] != 0) n++; return n;}
Could be written:while (s[n])
![Page 23: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/23.jpg)
CS 61C L03 C Arrays (23) A Carle, Summer 2006 © UCB
C Strings (1/3)•A string in C is just an array of characters.
char string[] = "abc";
•How do you tell how long a string is?• Last character is followed by a 0 byte (null terminator)int strlen(char s[]){ int n = 0; while (s[n] != 0) n++; /* ‘\0’ */ return n;}
![Page 24: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/24.jpg)
CS 61C L03 C Arrays (24) A Carle, Summer 2006 © UCB
C Strings Headaches (2/3)• One common mistake is to forget to allocate an
extra byte for the null terminator.
• More generally, C requires the programmer to manage memory manually (unlike Java or C++).
• When creating a long string by concatenating several smaller strings, the programmer must insure there is enough space to store the full string!
• What if you don’t know ahead of time how big your string will be?
• String constants are immutable:• char *f = “abc”; f[0]++; /* illegal */
- Because section of mem where “abc” lives is immutable.
• char f [ ] = “abc”; f[0]++; /* Works! */- Because, in declaration, c copies abc into space allocated for f.
![Page 25: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/25.jpg)
CS 61C L03 C Arrays (25) A Carle, Summer 2006 © UCB
C String Standard Functions (3/3)• int strlen(char *string);
• compute the length of string
• int strcmp(char *str1, char *str2);• return 0 if str1 and str2 are identical (how is
this different from str1 == str2?)
char *strcpy(char *dst, char *src);• copy the contents of string src to the memory
at dst and return dst. The caller must ensure that dst has enough memory to hold the data to be copied.
![Page 26: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/26.jpg)
CS 61C L03 C Arrays (26) A Carle, Summer 2006 © UCB
Pointer Arithmetic (1/5)•Since a pointer is just a mem address, we can add to it to traverse an array.
•p+1 returns a ptr to the next array elt.
•(*p)+1 vs *p++ vs *(p+1) vs *(p)++ ?• x = *p++ x = *p ; p = p + 1;• x = (*p)++ x = *p ; *p = *p + 1;
•What if we have an array of large structs (objects)?
• C takes care of it: In reality, p+1 doesn’t add 1 to the memory address, it adds the size of the array element.
![Page 27: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/27.jpg)
CS 61C L03 C Arrays (27) A Carle, Summer 2006 © UCB
Pointer Arithmetic (2/5)•So what’s valid pointer arithmetic?
• Add an integer to a pointer.
• Subtract 2 pointers (in the same array).
• Compare pointers (<, <=, ==, !=, >, >=)
• Compare pointer to NULL (indicates that the pointer points to nothing).
•Everything else is illegal since it makes no sense:
• adding two pointers
• multiplying pointers
• subtract pointer from integer
![Page 28: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/28.jpg)
CS 61C L03 C Arrays (28) A Carle, Summer 2006 © UCB
Pointer Arithmetic (3/5)•We can use pointer arithmetic to “walk” through memory:
°C automatically adjusts the pointer by the right amount each time (i.e., 1 byte for a char, 4 bytes for an int, etc.)
void copy(int *from, int *to, int n) { int i; for (i=0; i<n; i++) { *to++ = *from++; }}
![Page 29: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/29.jpg)
CS 61C L03 C Arrays (29) A Carle, Summer 2006 © UCB
int get(int array[], int n){ return (array[n]);
/* OR */ return *(array + n);}
Pointer Arithmetic (4/5)•C knows the size of the thing a pointer points to – every addition or subtraction moves that many bytes.
•So the following are equivalent:
![Page 30: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/30.jpg)
CS 61C L03 C Arrays (30) A Carle, Summer 2006 © UCB
Pointer Arithmetic (5/5)•Array size n; want to access from 0 to n-1 • test for exit by comparing to address one element past the array
int ar[10], *p, *q, sum = 0;...p = ar; q = &(ar[10]);while (p != q) /* sum = sum + *p; p = p + 1; */
sum += *p++;• Is this legal?
•C defines that one element past end of array must be a valid address, i.e., not cause an bus error or address error
![Page 31: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/31.jpg)
CS 61C L03 C Arrays (31) A Carle, Summer 2006 © UCB
Pointer Arithmetic Summary• x = *(p+1) ?
x = *(p+1) ;
• x = *p+1 ? x = (*p) + 1 ;
• x = (*p)++ ? x = *p ; *p = *p + 1;
• x = *p++ ? (*p++) ? *(p)++ ? *(p++) ? x = *p ; p = p + 1;
• x = *++p ? p = p + 1 ; x = *p ;
• Lesson?• These cause more problems than they solve!
![Page 32: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/32.jpg)
CS 61C L03 C Arrays (32) A Carle, Summer 2006 © UCB
Pointer Arithmetic Peer Instruction Q
How many of the following are invalid?I. pointer + integerII. integer + pointerIII. pointer + pointerIV. pointer – integerV. integer – pointerVI. pointer – pointerVII. compare pointer to pointerVIII. compare pointer to integerIX. compare pointer to 0X. compare pointer to NULL
![Page 33: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/33.jpg)
CS 61C L03 C Arrays (33) A Carle, Summer 2006 © UCB
• How many of the following are invalid?I. pointer + integerII. integer + pointerIII. pointer + pointerIV. pointer – integerV. integer – pointerVI. pointer – pointerVII. compare pointer to pointerVIII. compare pointer to integerIX. compare pointer to 0X. compare pointer to NULL
Pointer Arithmetic Peer Instruction A
ptr + 11 + ptr
ptr + ptrptr - 11 - ptr
ptr - ptrptr1 == ptr2
ptr == 1ptr == NULLptr == NULL
![Page 34: CS 61C L03 C Arrays (1) A Carle, Summer 2006 © UCB inst.eecs.berkeley.edu/~cs61c/ CS61C : Machine Structures Lecture #3: C Pointers & Arrays 2006-06-28.](https://reader030.fdocuments.in/reader030/viewer/2022032523/56649d7e5503460f94a6092e/html5/thumbnails/34.jpg)
CS 61C L03 C Arrays (34) A Carle, Summer 2006 © UCB
“And in Conclusion…”•Pointers and arrays are virtually same
•C knows how to increment pointers
•C is an efficient language, with little protection
• Array bounds not checked
• Variables not automatically initialized
• (Beware) The cost of efficiency is more overhead for the programmer.
• “C gives you a lot of extra rope but be careful not to hang yourself with it!”