1 / 20

CS 31 Discussion, Week 6

CS 31 Discussion, Week 6. Faisal Alquaddoomi, faisal@cs.ucla.edu Office Hours: BH 2432, W 4:30-6:30pm, F 12:30-1:30pm. 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). Arrays Review.

snow
Télécharger la présentation

CS 31 Discussion, Week 6

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. CS 31 Discussion, Week 6 Faisal Alquaddoomi, faisal@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: intmyArray[200]; • You can also statically allocate arrays, with or without setting the size (it’s set automatically if you leave it out): intmyOtherArray[] = { 1, 3, 5, 7, 9, 11 }; • Array slots are numbed 0 to length-1, e.g. intsomeArray[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(constint list[], intlen){ for (inti = 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-3str[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 <cstring> in these key functions:

  13. A Brief Notation Note • You may occasionally see a character array (or any array) taken as a parameter like so:intstrlen(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:intmyArray[10][10]; • // ^ has 10*10 == 100 slots • Accessing and setting an element:int p = myArray[3][7]; // row 3, col 7myArray[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:intmultTable[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)intmyArray[10][15];for (inti = 0; i < 10; i++) { // #1 for (int j = 0; j < 15; j++) { // #2myArray[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 <cstring> library, e.g. #include <cstring> • 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:intmyArray[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… */ }

More Related