CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with...
Transcript of CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with...
![Page 1: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/1.jpg)
1This document is copyright (C) Stanford Computer Science and Nick Troccoli, licensed under Creative Commons Attribution 2.5 License. All rights reserved.
Based on slides created by Marty Stepp, Cynthia Lee, Chris Gregg, and others.
CS107, Lecture 5More C Strings
Reading: K&R (1.6, 5.5, Appendix B3) or Essential C section 3
![Page 2: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/2.jpg)
2
Plan For Today• Recap: String Operations• Demo: Buffer Overflow and Valgrind• Arrays of Strings• Practice: Password Verification• Pointers• Announcements• Strings in Memory• Pointers to Strings
![Page 3: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/3.jpg)
3
Plan For Today• Recap: String Operations• Demo: Buffer Overflow and Valgrind• Arrays of Strings• Practice: Password Verification• Pointers• Announcements• Strings in Memory• Pointers to Strings
![Page 4: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/4.jpg)
4
C StringsC strings are arrays of characters, ending with a null-terminating character '\0'.
String operations use the null-terminating character to find the end of the string.E.g. strlen calculates string length by counting up the characters it sees beforereaching a null-terminating character.
index 0 1 2 3 4 5 6 7 8 9 10 11 12 13value 'H' 'e' 'l' 'l' 'o' ',' ' ' 'w' 'o' 'r' 'l' 'd' '!' '\0'
![Page 5: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/5.jpg)
5
Common string.h FunctionsFunction Description
strlen(str) returns the # of chars in a C string (before null-terminating character).strcmp(str1, str2), strncmp(str1, str2, n)
compares two strings; returns 0 if identical, <0 if str1 comes before str2 in alphabet, >0 if str1 comes after str2 in alphabet. strncmpstops comparing after at most n characters.
strchr(str, ch)strrchr(str, ch)
character search: returns a pointer to the first occurrence of ch in str, or NULL if ch was not found in str. strrchr find the last occurrence.
strstr(haystack, needle) string search: returns a pointer to the start of the first occurrence of needle in haystack, or NULL if needle was not found in haystack.
strcpy(dst, src),strncpy(dst, src, n)
copies characters in src to dst, including null-terminating character. Assumes enough space in dst. Strings must not overlap. strncpystops after at most n chars, and does not add null-terminating char.
strcat(dst, src),strncat(dst, src, n)
concatenate src onto the end of dst. strncat stops concatenating after at most n characters. Always adds a null-terminating character.
strspn(str, accept),strcspn(str, reject)
strspn returns the length of the initial part of str which contains onlycharacters in accept. strcspn returns the length of the initial part of str which does not contain any characters in reject.
![Page 6: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/6.jpg)
6
C Strings As ParametersRegardless of how you created the string, when you pass a string as a parameter it is always passed as a char *. char * still lets you use bracket notation to access individual characters (How? We’ll see later today!).
int doSomething(char *str) {char secondChar = str[1];...
}
// can also write this, but it is really a pointerint doSomething(char str[]) { ...
![Page 7: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/7.jpg)
7
Buffer Overflows• It is your responsibility to ensure that memory operations you perform don’t
improperly read or write memory.• E.g. don’t copy a string into a space that is too small!• E.g. don’t ask for the string length of an uninitialized string!
• The Valgrind tool may be able to help track down memory-related issues.• See cs107.stanford.edu/resources/valgrind• We’ll talk about Valgrind more when we talk about dynamically-allocated memory.
![Page 8: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/8.jpg)
8
Demo: Memory Errors
![Page 9: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/9.jpg)
9
Plan For Today• Recap: String Operations• Demo: Buffer Overflow and Valgrind• Arrays of Strings• Practice: Password Verification• Pointers• Announcements• Strings in Memory• Pointers to Strings
![Page 10: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/10.jpg)
10
Arrays of StringsYou can make an array of strings to group multiple strings together:
char *stringArray[5]; // space to store 5 char *s
You can also use the following shorthand to initialize a string array:
char *stringArray[] = {"my string 1","my string 2","my string 3"
};
![Page 11: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/11.jpg)
11
Arrays of StringsYou can access each string using bracket syntax:
printf("%s\n", stringArray[0]); // print out first string
When an array of strings is passed as a parameter, it is passed as a pointer to the first element of the string array. This is what argv is in main! This means you write the parameter type as:
void myFunction(char **stringArray) {
// equivalent to this, but it is really a double pointervoid myFunction(char *stringArray[]) {
![Page 12: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/12.jpg)
12
Practice: Password VerificationWrite a function verifyPassword that accepts a candidate password and certain password criteria, and returns whether the password is valid.
bool verifyPassword(char *password, char *validChars, char *badSubstrings[], int numBadSubstrings);
password is valid if it contains only letters in validChars, and does not contain any substrings in badSubstrings.
![Page 13: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/13.jpg)
13
Practice: Password Verificationbool verifyPassword(char *password, char *validChars, char *badSubstrings[], int numBadSubstrings);
Example:
char *invalidSubstrings[] = { "1234" };
bool valid = verifyPassword("1572", "0123456789",invalidSubstrings, 1); // true
bool valid = verifyPassword("141234", "0123456789",invalidSubstrings, 1); // false
![Page 14: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/14.jpg)
14
Practice: Password Verification
![Page 15: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/15.jpg)
15
Plan For Today• Recap: String Operations• Demo: Buffer Overflow and Valgrind• Arrays of Strings• Practice: Password Verification• Pointers• Announcements• Strings in Memory• Pointers to Strings
![Page 16: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/16.jpg)
16
Pointers• A pointer is a variable that stores a memory address.• Because there is no pass-by-reference in C like in C++, pointers let us pass
around the address of one instance of memory, instead of making many copies.• One (8 byte) pointer can refer to any size memory location!• Pointers are also essential for allocating memory on the heap, which we will
cover later.• Pointers also let us refer to memory generically, which we will cover later.
![Page 17: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/17.jpg)
17
Pointersint x = 2;
// Make a pointer that stores the address of x.// (& means "address of")int *xPtr = &x;
// Dereference the pointer to get the data it points to.// (* means "dereference")printf("%d", *xPtr); // prints 2
![Page 18: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/18.jpg)
18
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
mainSTACK
![Page 19: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/19.jpg)
19
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
main
x 2
STACK
![Page 20: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/20.jpg)
20
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
main
x 2
STACK
![Page 21: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/21.jpg)
21
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
main
x
myFunc
intPtr
2
STACK
![Page 22: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/22.jpg)
22
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
main
x
myFunc
intPtr
2
STACK
![Page 23: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/23.jpg)
23
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
main
x
myFunc
intPtr
3
STACK
![Page 24: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/24.jpg)
24
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
main
x 3
STACK
![Page 25: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/25.jpg)
25
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
main
x 3
STACK
![Page 26: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/26.jpg)
26
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
Address Value
…
…main()
STACK
![Page 27: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/27.jpg)
27
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
Address Value
…
0x105 2
…
xmain()
STACK
![Page 28: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/28.jpg)
28
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
Address Value
…
0x105 2
…
xmain()
STACK
![Page 29: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/29.jpg)
29
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
Address Value
…
0x105 2
…
…
0xf0 0x105
…
x
intPtr
main()
myFunc()
STACK
![Page 30: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/30.jpg)
30
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
Address Value
…
0x105 2
…
…
0xf0 0x105
…
x
intPtr
main()
myFunc()
STACK
![Page 31: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/31.jpg)
31
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
Address Value
…
0x105 3
…
…
0xf0 0x105
…
x
intPtr
main()
myFunc()
STACK
![Page 32: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/32.jpg)
32
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
Address Value
…
0x105 3
…
xmain()
STACK
![Page 33: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/33.jpg)
33
PointersA pointer is just a variable that stores a memory address!
void myFunc(int *intPtr) {*intPtr = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(&x);printf("%d", x); // 3!...
}
Address Value
…
0x105 3
…
xmain()
STACK
![Page 34: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/34.jpg)
34
PointersWithout pointers, we would make copies.
void myFunc(int val) {val = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(x);printf("%d", x); // 2!...
}
Address Value
…
…main()
STACK
![Page 35: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/35.jpg)
35
PointersWithout pointers, we would make copies.
void myFunc(int val) {val = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(x);printf("%d", x); // 2!...
}
Address Value
…
0x105 2
…
xmain()
STACK
![Page 36: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/36.jpg)
36
PointersWithout pointers, we would make copies.
void myFunc(int val) {val = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(x);printf("%d", x); // 2!...
}
Address Value
…
0x105 2
…
xmain()
STACK
![Page 37: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/37.jpg)
37
PointersWithout pointers, we would make copies.
void myFunc(int val) {val = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(x);printf("%d", x); // 2!...
}
Address Value
…
0x105 2
…
…
0xf0 2
…
x
val
main()
myFunc()
STACK
![Page 38: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/38.jpg)
38
PointersWithout pointers, we would make copies.
void myFunc(int val) {val = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(x);printf("%d", x); // 2!...
}
Address Value
…
0x105 2
…
…
0xf0 2
…
x
val
main()
myFunc()
STACK
![Page 39: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/39.jpg)
39
PointersWithout pointers, we would make copies.
void myFunc(int val) {val = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(x);printf("%d", x); // 2!...
}
Address Value
…
0x105 2
…
…
0xf0 3
…
x
val
main()
myFunc()
STACK
![Page 40: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/40.jpg)
40
PointersWithout pointers, we would make copies.
void myFunc(int val) {val = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(x);printf("%d", x); // 2!...
}
Address Value
…
0x105 2
…
xmain()
STACK
![Page 41: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/41.jpg)
41
PointersWithout pointers, we would make copies.
void myFunc(int val) {val = 3;
}
int main(int argc, char *argv[]) {int x = 2;myFunc(x);printf("%d", x); // 2!...
}
Address Value
…
0x105 2
…
xmain()
STACK
![Page 42: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/42.jpg)
42
Plan For Today• Recap: String Operations• Demo: Buffer Overflow and Valgrind• Arrays of Strings• Practice: Password Verification• Pointers• Announcements• Strings in Memory• Pointers to Strings
![Page 43: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/43.jpg)
43
Announcements• Assignment 1 due Monday 1/21 11:59PM PST• Grace period until Wed. 1/23 11:59PM PST
• Lab 2: C strings practice• Assignment 2 released at Assignment 1 due date• Due Mon. 1/28 11:59PM PST, grace period until Wed. 1/30 11:59PM PST• Programs using C strings• Style guide published on course website
![Page 44: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/44.jpg)
44
Plan For Today• Recap: String Operations• Demo: Buffer Overflow and Valgrind• Arrays of Strings• Practice: Password Verification• Pointers• Announcements• Strings in Memory• Pointers to Strings
![Page 45: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/45.jpg)
45
Character ArraysAddress Value
…
0x105 '\0'
0x104 'e'
0x103 'l'
0x102 'p'
0x101 'p'
0x100 'a'
…
When you declare an array of characters, contiguous memory is allocated on the stack to store the contents of the entire array.
char str[6] = "apple";
The array variable (e.g. str) is not a pointer; it refers to the entire array contents. In fact, sizeof returns the size of the entire array!
int arrayBytes = sizeof(str); // 6(so then why do we need strlen? We’ll see soon!)
str
STACK
![Page 46: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/46.jpg)
46
Character ArraysAn array variable refers to an entire block of memory. You cannot reassign an existing array to be equal to a new array.
char str[6] = "apple";char str2[8] = "apple 2";str = str2; // not allowed!
An array’s size cannot be changed once you create it; you must create another new array instead.
![Page 47: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/47.jpg)
47
char *
Address Value…
0x105 0x10……
0x12 '\0'0x11 'i'0x10 'h'
…
When you declare a char pointer equal to a string literal, the string literal is not stored on the stack. Instead, it’s stored in a special area of memory called the “Text segment”. You cannot modify memory in this segment.char *str = "hi";The pointer variable (e.g. str) refers to the address of the first character of the string in the text segment. Since this variable is just a pointer, sizeof returns 8, no matter the total size of the string!
int stringBytes = sizeof(str); // 8
strSTACK
TEXT SEGMENT
![Page 48: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/48.jpg)
48
char *
A char * variable refers to a single character. You can reassign an existing char *pointer to be equal to another char * pointer.
char *str = "apple"; // e.g. 0xff5char *str2 = "apple 2"; // e.g. 0xfe2str = str2; // ok! Both store address 0xfe2
![Page 49: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/49.jpg)
49
Arrays and PointersYou can also make a pointer equal to an array; it will point to the first element in that array.
int main(int argc, char *argv[]) {char str[6] = "apple";char *ptr = str;...
}
Address Value…
0x105 '\0'0x104 'e'0x103 'l'0x102 'p'0x101 'p'0x100 'a'0xf8 0x100
…
str
ptr
main()
STACK
![Page 50: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/50.jpg)
50
Arrays and PointersYou can also make a pointer equal to an array; it will point to the first element in that array.
int main(int argc, char *argv[]) {char str[6] = "apple";char *ptr = str;
// equivalentchar *ptr = &str[0];
// equivalent, but avoidchar *ptr = &str;...
}
Address Value
…
0x105 '\0'
0x104 'e'
0x103 'l'
0x102 'p'
0x101 'p'
0x100 'a'
0xf8 0x100
…
str
ptr
main()
STACK
![Page 51: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/51.jpg)
51
Pointer ArithmeticWhen you do pointer arithmetic, you are adjusting the pointer by a certain number of places (e.g. characters).
char *str = "apple"; // e.g. 0xff1char *str2 = str + 1; // e.g. 0xff2char *str3 = str + 3; // e.g. 0xff4
printf("%s", str); // appleprintf("%s", str2); // ppleprintf("%s", str3); // le
Address Value
…
0xff6 '\0'
0xff5 'e'
0xff4 'l'
0xff3 'p'
0xff2 'p'
0xff1 'a'
…
TEXT SEGMENT
![Page 52: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/52.jpg)
52
Pointer ArithmeticPointer arithmetic does not add bytes. Instead, it adds the size of the type it points to.
// nums points to an int arrayint *nums = … // e.g. 0xff1int *nums2 = nums + 1; // e.g. 0xff5int *nums3 = nums + 3; // e.g. 0xffd
printf("%d", *nums); // 52printf("%d", *nums2); // 23printf("%d", *nums3); // 34
Address Value
…
0x1005 1
0x1001 16
0xffd 34
0xff9 12
0xff5 23
0xff1 52
…
STACK
![Page 53: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/53.jpg)
53
char *
When you use bracket notation with a pointer, you are actually performing pointer arithmetic and dereferencing:
char *str = "apple"; // e.g. 0xff1
// both of these add two places to str,// and then dereference to get the char there.// E.g. get memory at 0xff3.char thirdLetter = str[2]; // 'p'char thirdLetter = *(str + 2); // 'p'
Address Value
…
0xff6 '\0'
0xff5 'e'
0xff4 'l'
0xff3 'p'
0xff2 'p'
0xff1 'a'
…
TEXT SEGMENT
![Page 54: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/54.jpg)
54
Strings as ParametersWhen you pass a char * string as a parameter, C makes a copy of the address stored in the char *, and passes it to the function. This means they both refer to the same memory location.
void myFunc(char *myStr) {…
}
int main(int argc, char *argv[]) {char *str = "apple";myFunc(str);...
}
Address Value
…
0x105 0xff1
…
…
0xf0 0xff1
…
str
myStr
main()
myFunc()
STACK
![Page 55: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/55.jpg)
55
Strings as ParametersWhen you pass a char array as a parameter, C makes a copy of the address of the first array element, and passes it (as a char *) to the function.
void myFunc(char *myStr) {…
}
int main(int argc, char *argv[]) {char str[6] = "apple";myFunc(str);...
}
Address Value…
0x105 '\0'0x104 'e'0x103 'l'0x102 'p'0x101 'p'0x100 'a'
……
0xf 0x100…
str
myStr
main()
myFunc()
STACK
![Page 56: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/56.jpg)
56
Strings as ParametersWhen you pass a char array as a parameter, C makes a copy of the address of the first array element, and passes it (as a char *) to the function.
void myFunc(char *myStr) {…
}
int main(int argc, char *argv[]) {char str[6] = "apple";// equivalentchar *arrPtr = str;myFunc(arrPtr);...
}
Address Value…
0x105 '\0'0x104 'e'0x103 'l'0x102 'p'0x101 'p'0x100 'a'
……
0xf 0x100…
str
myStr
main()
myFunc()
STACK
![Page 57: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/57.jpg)
57
Strings as ParametersThis means if you modify characters in myFunc, the changes will persist back in main!
void myFunc(char *myStr) {myStr[4] = 'y';
}
int main(int argc, char *argv[]) {char str[6] = "apple";myFunc(str);printf("%s", str); // apply...
}
Address Value…
0x105 '\0'0x104 'e'0x103 'l'0x102 'p'0x101 'p'0x100 'a'
……
0xf 0x100…
str
myStr
main()
myFunc()
STACK
![Page 58: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/58.jpg)
58
Strings as ParametersThis means if you modify characters in myFunc, the changes will persist back in main!
void myFunc(char *myStr) {myStr[4] = 'y';
}
int main(int argc, char *argv[]) {char str[6] = "apple";myFunc(str);printf("%s", str); // apply...
}
Address Value…
0x105 '\0'0x104 'y'0x103 'l'0x102 'p'0x101 'p'0x100 'a'
……
0xf 0x100…
str
myStr
main()
myFunc()
STACK
![Page 59: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/59.jpg)
59
Strings as ParametersThis also means we can no longer get the full size of the array using sizeof, because now it is just a regular char * pointer.
void myFunc(char *myStr) {int size = sizeof(myStr); // 8
}
int main(int argc, char *argv[]) {char str[6] = "apple";int size = sizeof(str); // 6myFunc(str);...
}
Address Value…
0x105 '\0'0x104 'e'0x103 'l'0x102 'p'0x101 'p'0x100 'a'
……
0xf 0x100…
str
myStr
main()
myFunc()
STACK
![Page 60: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/60.jpg)
60
Strings and MemoryThese memory behaviors explain why strings behave the way they do:1. We can modify a string created as a char[] because its memory lives in our
stack space.2. We cannot modify a string created as a char* because its memory does not
live in our stack space; it lives in the text segment.3. We can set a char* equal to another value, because it is just a pointer.4. We cannot set a char[] equal to another value, because it is not a pointer; it
refers to the block of memory reserved for the original array.5. If we change characters in a string passed to a function, these changes will
persist outside of the function.6. When we pass a char array as a parameter, we can no longer use sizeof to
get its full size.
![Page 61: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/61.jpg)
61
Demo: Strings and Memory
![Page 62: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/62.jpg)
62
Plan For Today• Recap: String Operations• Demo: Buffer Overflow and Valgrind• Arrays of Strings• Practice: Password Verification• Pointers• Announcements• Strings in Memory• Pointers to Strings
![Page 63: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/63.jpg)
63
Pointers to StringsSometimes, we would like to modify a string’s pointer itself, rather than just the characters it points to.• Ex. Write a function skipCSPrefix that takes in a char * representing a class
name, and modifies it to advance past the “CS” prefix, if any, in the string.
char *myStr = "CS41";skipCSPrefix(&myStr);printf("%s\n", myStr); // 41
![Page 64: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/64.jpg)
64
Pointers to Stringsvoid skipCSPrefix(char **strPtr) {
char *prefix = strstr(*strPtr, "CS");if (prefix != NULL && prefix == *strPtr) {
*strPtr += strlen("CS");}
}
int main(int argc, char *argv[]) {char *myStr = "CS41";skipCSPrefix(&myStr);printf("%s\n", myStr); // 41return 0;
}
Address Value
…
…main()STACK
![Page 65: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/65.jpg)
65
Pointers to StringsAddress Value
…
0x105 0xf
…
…
0x13 '\0'
0x12 '1'
0x11 '4'
0x10 'S'
0xf 'C'
…
myStr
TEXT SEGMENT
void skipCSPrefix(char **strPtr) {
char *prefix = strstr(*strPtr, "CS");
if (prefix != NULL && prefix == *strPtr) {
*strPtr += strlen("CS");
}
}
int main(int argc, char *argv[]) {
char *myStr = "CS41";
skipCSPrefix(&myStr);
printf("%s\n", myStr); // 41
return 0;
}
main()STACK
![Page 66: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/66.jpg)
66
Pointers to StringsAddress Value
…
0x105 0xf
…
…
0x13 '\0'
0x12 '1'
0x11 '4'
0x10 'S'
0xf 'C'
…
myStr
TEXT SEGMENT
void skipCSPrefix(char **strPtr) {
char *prefix = strstr(*strPtr, "CS");
if (prefix != NULL && prefix == *strPtr) {
*strPtr += strlen("CS");
}
}
int main(int argc, char *argv[]) {
char *myStr = "CS41";
skipCSPrefix(&myStr);
printf("%s\n", myStr); // 41
return 0;
}
main()STACK
![Page 67: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/67.jpg)
67
Pointers to StringsAddress Value
…
0x105 0xf
…
…
0xf0 0x105
…
…
0x13 '\0'
0x12 '1'
0x11 '4'
0x10 'S'
0xf 'C'
…
TEXT SEGMENT
void skipCSPrefix(char **strPtr) {char *prefix = strstr(*strPtr, "CS");if (prefix != NULL && prefix == *strPtr) {
*strPtr += strlen("CS");}
}
int main(int argc, char *argv[]) {char *myStr = "CS41";skipCSPrefix(&myStr);printf("%s\n", myStr); // 41return 0;
}
myStr
strPtr
main()
skipCSPrefix()
STACK
![Page 68: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/68.jpg)
68
Pointers to StringsAddress Value
…
0x105 0xf
…
…
0xf0 0x105
0xe8 0xf…
…
0x13 '\0'
0x12 '1'
0x11 '4'
0x10 'S'
0xf 'C'
…
TEXT SEGMENT
void skipCSPrefix(char **strPtr) {char *prefix = strstr(*strPtr, "CS");if (prefix != NULL && prefix == *strPtr) {
*strPtr += strlen("CS");}
}
int main(int argc, char *argv[]) {char *myStr = "CS41";skipCSPrefix(&myStr);printf("%s\n", myStr); // 41return 0;
}
myStr
strPtr
prefix
main()
skipCSPrefix()
STACK
![Page 69: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/69.jpg)
69
Pointers to StringsAddress Value
…
0x105 0xf
…
…
0xf0 0x105
0xe8 0xf
…
…
0x13 '\0'
0x12 '1'
0x11 '4'
0x10 'S'
0xf 'C'
…
TEXT SEGMENT
void skipCSPrefix(char **strPtr) {char *prefix = strstr(*strPtr, "CS");if (prefix != NULL && prefix == *strPtr) {
*strPtr += strlen("CS");}
}
int main(int argc, char *argv[]) {char *myStr = "CS41";skipCSPrefix(&myStr);printf("%s\n", myStr); // 41return 0;
}
myStr
strPtr
prefix
main()
skipCSPrefix()
STACK
![Page 70: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/70.jpg)
70
Pointers to StringsAddress Value
…
0x105 0xf
…
…
0xf0 0x105
0xe8 0xf
…
…
0x13 '\0'
0x12 '1'
0x11 '4'
0x10 'S'
0xf 'C'
…
TEXT SEGMENT
void skipCSPrefix(char **strPtr) {char *prefix = strstr(*strPtr, "CS");if (prefix != NULL && prefix == *strPtr) {
*strPtr += strlen("CS");}
}
int main(int argc, char *argv[]) {char *myStr = "CS41";skipCSPrefix(&myStr);printf("%s\n", myStr); // 41return 0;
}
myStr
strPtr
prefix
main()
skipCSPrefix()
STACK
![Page 71: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/71.jpg)
71
Pointers to StringsAddress Value
…
0x105 0x11…
…
0xf0 0x105
0xe8 0xf
…
…
0x13 '\0'
0x12 '1'
0x11 '4'
0x10 'S'
0xf 'C'
…
TEXT SEGMENT
void skipCSPrefix(char **strPtr) {char *prefix = strstr(*strPtr, "CS");if (prefix != NULL && prefix == *strPtr) {
*strPtr += strlen("CS");}
}
int main(int argc, char *argv[]) {char *myStr = "CS41";skipCSPrefix(&myStr);printf("%s\n", myStr); // 41return 0;
}
myStr
strPtr
prefix
main()
skipCSPrefix()
STACK
![Page 72: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/72.jpg)
72
Pointers to StringsAddress Value
…
0x105 0x11
…
…
0x13 '\0'
0x12 '1'
0x11 '4'
0x10 'S'
0xf 'C'
…
TEXT SEGMENT
void skipCSPrefix(char **strPtr) {char *prefix = strstr(*strPtr, "CS");if (prefix != NULL && prefix == *strPtr) {
*strPtr += strlen("CS");}
}
int main(int argc, char *argv[]) {char *myStr = "CS41";skipCSPrefix(&myStr);printf("%s\n", myStr); // 41return 0;
}
myStrSTACK main()
![Page 73: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/73.jpg)
73
Pointers to StringsAddress Value
…
0x105 0x11
…
…
0x13 '\0'
0x12 '1'
0x11 '4'
0x10 'S'
0xf 'C'
…
TEXT SEGMENT
void skipCSPrefix(char **strPtr) {char *prefix = strstr(*strPtr, "CS");if (prefix != NULL && prefix == *strPtr) {
*strPtr += strlen("CS");}
}
int main(int argc, char *argv[]) {char *myStr = "CS41";skipCSPrefix(&myStr);printf("%s\n", myStr); // 41return 0;
}
myStrmain()STACK
![Page 74: CS107, Lecture 5 - Stanford University...4 C Strings C strings are arrays of characters, ending with a null-terminating character'\0'.String operations use the null-terminating character](https://reader035.fdocuments.us/reader035/viewer/2022071604/61401953e59fcb3c636a47b0/html5/thumbnails/74.jpg)
74
Recap• Recap: String Operations• Demo: Buffer Overflow and Valgrind• Arrays of Strings• Practice: Password Verification• Pointers• Announcements• Strings in Memory• Pointers to Strings
Next time: Arrays and Pointers