1. CS 31 Discussion, Week 6 Faisal Alquaddoomi, faisal@cs.ucla.edufaisal@cs.ucla.edu Office Hours: BH 2432, W 4:30-6:30pm, F 12:30-1:30pm

2. Notes and Agenda Slides are now online: http://cs.ucla.edu/~faisal/ Arrays Recap C-Strings 2D Arrays Memory and the Stack – (optional, on board)

3. Arrays Review Arrays are useful for dealing with large numbers of values Create an array like so, specifying the type, name and size: int myArray[200]; You can also statically allocate arrays, with or without setting the size (it’s set automatically if you leave it out): int myOtherArray[] = { 1, 3, 5, 7, 9, 11 }; Array slots are numbed 0 to length-1, e.g. int someArray[10]; // size 10, slots 0-9

4. Arrays Review #2 Arrays can be passed to functions – They’re always passed by reference Can prevent modification using “const” modifier – Syntax for taking an array as a parameter: void printAll(const int list[], int len) { for (int i = 0; i < len; i++) { cout << “#” << (i+1); cout << “: “ << list[i] << endl; } Don’t go past the end of an array or before the beginning!

5. C-Strings A “C-String” is just an array of characters! For instance: char text[10]; // 10 characters As we’ve mentioned, arrays can be of any type, including chars Convenient for representing text when the string class wasn’t around Can be used with cout, can be assigned to strings, etc. (as we’ll describe) But remember that we have trouble with array sizes – e.g. we have to pass them around all the time and be sure not to run off the end or else…

6. Nul-Termination The solution to the array size problem is nul-termination By convention, a special element that indicates the end of the text in a C-String is a literal 0 – (not the character ‘0’, which is 48) – Referred to in the literature as a ‘nul-terminator’ the ‘nul’ part because it’s 0, and the ‘terminator’ part because it ends the string – You may also see the 0 represented as ‘\0’, which is an escape code that also has the literal value 0 Chosen to allow the length of a C-String to be determined by just examining the elements – Unlike your project, we don’t have to pass around the length of C-Strings (at least if they’re well-formed) – Also implies that a 0 cannot occur within the text itself Also, if the nul-terminator is missing, things will go badly in your life (more on this later)

7. Creating a C-String Just like any other array, but with some shortcuts (that we’ll see later) Creating a C-String with “Hi!” in it, the hard way: char str[4]; // size 4, slots 0-3 str[0] = ‘H’; str[1] = ‘i’; str[2] = ‘!’; str[3] = 0; // the nul-terminator

8. Creating a C-String, Cont’d Marginally easier way: char str[4] = {‘H’, ‘i’, ‘!’, ‘\0’}; Even easier: char str[4] = “Hi!”; The above automatically inserts the nul- terminator for us – which is why the char array is still of length 4 – …although it could have been any size >= 4 All of the literal strings you’ve seen so far have been C-Strings all along

9. C-Strings as Parameters and Arguments Taking a C-String as a parameter: void takesCStr(char str[]) { /* etc */ } – You can use ‘const’ before the ‘char’ in order to prevent it from being modified Passing a C-String as an argument: char myStr[] = “Test”; takeCStr(myStr); Largely the same as arrays (since C-strings are arrays)

10. Operations with C-Strings Unlike regular strings, you can’t do much with C-Strings without help from some library functions You can do a few operations given this array: char str[] = “Hi!”; Print it: cout << str << endl; Read it: cin >> str; // ‘str’ must be big enough Get a character out of it, or change a character: char p = str[2]; // p == ‘!’ str[0] = ‘P’; // str is now “Pi!” Aside from the printing/reading, pretty much things you’d do with normal arrays…

11. Things You Can’t do With C-Strings Compare two C-strings: char a[] = “Hello!”; char b[] = {‘H’, ‘e’, ‘l’, ‘l’, ‘o’, ‘!’, ‘\0’}; if (a == b) { /* nope */ } Concatenate two C-Strings: cout << a + b << endl; // nope Assign one C-String to another: a = b; // doesn’t work Check the size of a C-String: a.size(); // won’t work, sadly Thankfully, there are easy ways to do these things…

12. Library Functions for Strings #include in these key functions: Function SignatureWhat it does int strlen(const char str[]); Returns the length of str, ex: strlen(“Hi”) == 2 char *strcpy(char dest[], const char src[]); Copies src into dest, returns dest char *strcat(char dest[], const char src[]); Sticks src onto the end of dest, returns dest int strcmp(char str1[], char str2[]) Compares two strings, returning 0 if they’re equal

13. A Brief Notation Note You may occasionally see a character array (or any array) taken as a parameter like so: int strlen(const char *str); – That star means “pointer” in C/C++, but this won’t make any sense if you’re not familiar with memory and addressing – You can simply ignore this and pass an array when you see something that asks for a “char *” (or any other type, e.g. “int *”) for now… I intend to discuss pointers at the end of this lecture, time permitting and interest withstanding

14. 2D Arrays The arrays we discussed previously are technically called ‘1D arrays’ – Have a single ‘dimension’, e.g. myArray[10] has one dimension from 0 to 9 A 2D array is exactly the same as a 1D array in terms of use, except there are two dimensions Used for making tables, grids, matrices, etc. Project 3 used one to hold all the dots that appear on the screen

15. Creating and Accessing a 2D Array Similar to a 1D array, creating a 2D array: int myArray[10][10]; // ^ has 10*10 == 100 slots Accessing and setting an element: int p = myArray[3][7]; // row 3, col 7 myArray[9][9] = 9000; // ^ sets the last row, col By convention, the first dimension is the row and the second is the column

16. Statically Allocating a 2D Array Pretty similar to 1D arrays: int multTable[4][4] = { { 1, 2, 3, 4 }, { 2, 4, 6, 8 }, { 3, 6, 9, 12 }, { 4, 8, 12, 16 } }; // multTable[(3-1)][(2-1)] == 6 Unlike 1D arrays, we can only leave out the first dimension if we like; the second is required: multTable[][3] = { { 1, 2, 3 } };

17. 2D Arrays as Params, Arguments Take a 2D array as an argument like so: void myTwoDeeFunc(char input[][5]) { /* etc */ } Note that the second dimension must be specified (like in static allocation of 2D arrays earlier) – There’s a funny reason for this, which you’ll learn if you stick around for memory and the stack (optional) Passing a 2D array is the same as a 1D array: char stuff[3][5]; myTwoDeeFunc(stuff);

18. Processing an Entire 2D Array Typically uses an outer ‘for’ to go through the rows (#1)… …And an inner ‘for’ to go through the columns for each row (#2) int myArray[10][15]; for (int i = 0; i < 10; i++) { // #1 for (int j = 0; j < 15; j++) { // #2 myArray[i][j] = 0; // row i, col j } } // at the end, all slots are 0

19. Recap C-Strings are just char arrays, with some convenient functions for manipulating them – End in a ‘nul-terminator’ that signifies the end of the string – Leaving off the nul-terminator is disastrous C-Strings have special manipulation functions in the library, e.g. #include Whenever you use “Hello!” in your code, you’re using a C-String – (but thankfully std::string is good at converting from C-Strings to std::strings when needed)

20. Recap, Part 2 2D arrays are like 1D arrays, except they have an extra dimension – by convention, the first dimension is the row, the second is the column – declare: int myArray[5][10]; // 5 rows, 10 columns – access/change: myArray[2][3] = 888; // ^ item at row 2, col 3 is now 888 2D arrays can be statically allocated, but the second dimension (columns) must be specified Similarly, when writing a function that takes a 2D array as a parameter, the second dimension must also be specified: void myFunc(char inArray[][5]) { /* body of function here… */ }