### CS62 - Spring 2010 - Lecture 19

• Quiz: Exercise 15.3

Suppose you have a hash table with seven entries (indexed 0 through
6). This table uses open addressing with the hash function that maps each letter to its alphabet code (a = A = 0, etc.) modulo 7. Rehashing is accomplished using linear-probing with a jump of 1. Describe the state of the table after the letters D, a, d, H, a, and h are added to the table.

• hashtable size
- some rules of thumb
- ~half full (default for java is .75, http://java.sun.com/j2se/1.4.2/docs/api/java/util/HashMap.html) for open addressed hashtables
- why?
- recall, running time for most methods is O(1/1-alpha))
- alpha = .75 gives us O(4), but degrades rapidly after that
- prime number sizing
- what happens if the size of the hashtable is a power of 2, e.g. 2^p?
- if, like we did, we take the hashCode() and mod it with the hashtable size, what are we getting?
- moding by 2^p maps the number so the numbers 0... 2^p
- these are represented by the lower order p bits
- not a very good use since we throw away the upper order bits
- what happens if the load of our hashtable gets too large?
- similar to ArrayList, create a new table that's larger
- can we just copy the values over?
- no, need to rehash since we've changed the size of the table, e.g. if use used mod m, then entries would be wrong

• look at first.cpp code
- our first C++ program!
- what are some things that you notice that are common to Java?
- main method
- like Java, execution of the code starts in the main method
- int variables
- C++ has many of the standard types we've seen: int, double, float, char
- and a few ones that are slightly different:
- "long" in Java is "long int" in C++
- "boolean" in Java is "bool" in C++
- while we're on it, Java has 8 built in types:
- short, int, long, double, float, boolean, char, byte
- similar method construction
- return type
- method name
- parameters
- curly braces
- control constructs
- for loop
- if statement
- C++ has all the other familiar ones as well:
- while
- do-while
- switch
- if/else
- method invocation
- method name followed by parenthesis, which enclose the actual parameters
- class method invocation with '.'
- vector class
- use of generics with the vector class, i.e. <int>
- C++ has had generics for a while
- Java just got them for version 1.5, which came out a few years ago (the latest version is v1.6)
- C++ can be challenging to get right sometimes, but it should be noted many similarities there are between Java and C++
- what are the differences?
- where is the class???
- unlike java, C++ code does not need to be in a class
- in fact, although we will use multiple files to make our life easier, you can think of it as one gigantic chunk of code
- main method
- returns an int rather than being of type void
- don't forget to return a value
- a value of 0 means everything went ok
- any other value, reports an error
- doesn't have all that other stuff... public static
- why did it need to be static in Java?
- methods have to be inside a class
- but to call a non-static method, we need an instance of the class (chicken and the egg :)
- since it's not in a class, scope (public) isn't needed
- doesn't take any arguments
- though we can have a version that does take command-line arguments, but that's for another day
- #include???
- C++ can be thought of as one giant file of code (eventually)
- if we need to use code from another class, we need to use #include
- anything starting with # is called a pre-processor directective
- the preprocessor runs before the compiler does
- it can manipulate files, etc.
- #include <x> says "copy the code from 'x' at the beginning of this file"
- <> denotes a built-in, system class
- we can use quotes "" to denote a user class/file and give the path to the file
- using namespace std
- what does the import command do in Java?
- the import command makes our life easier
- let's say we want to use the ArrayList class
- we could specify the full package path and use it that way:

java.util.ArrayList list = new java.util.ArrayList();

- this gets old pretty quickly
- if we import java.util.Arraylist, that says to make ArrayList part of our namespace, that is, whenever we refer to ArrayList, we're actually referring to java.util.ArrayList
- in C++, the "using namespace std" commands tells the compiler to allow everything in the "std" namespace to be referred to without having to do anything special
- equivalent of saying "import std" or something similar in Java
- in C++, to refer to something in a namespace you type the name of the namespace followed by "::", i.e. "std::"
- the vector class is in the std namespace, so it saves us from writing std::vector everywhere
- in general, for most of our programs, you'll want to have this there (don't forget!!!)
- vector
- vector, similar to the Java Vector (or ArrayList) class
- what happened to the "get" and "set" methods of Java?
- in C++, you can access vector elements using the "[]"
- in fact, there is no get or set method in the sense that Java has
- why does this work?
- one of the neat things you can do in C++ is "operator overloading"
- what is an operator?
- special symbols that perform specific operations
- what operators have we seen?
- +, -, ...
- =, +=, ...
- ==, !=, <=
- &, |, ^
- <<, >>
- ++, --
- ?
- in C++, a class can change the functionality of built-in operators, e.g. '=', '<<' or, in this case '[]'
- Java can't do this, which is why we need methods like "equals"
- it looks like in the simpleVersion method we're just creating a new variable to hold a vector, but this actually creates a vector!
- "vector<int> nums" calls the zero parameter constructor in the vector class
- how do we call constructors with parameters?
- "vector<int> nums(10)" call the constructor with one parameter in the vector class
- be careful!
- "vector<int> nums()" does NOT call the zero parameter constructor
- you'll get a compiler error
- vector class is sort of a blend of arrays and ArrayList class
- like noted above, we can use the '[]' operators on it to access items
- notice that when we call the one parameter constructor, we can access the elements

vector<int> nums(10);
nums[8] = 10;

- what would happen if we did this in Java?
- index out of bounds exception
- what do you think will happen if we do:

vector<int> nums;
nums[8] = 10;

run-time error (aka segmentation fault), just like Java, we cannot access elements in the vector that have not be instantiated (either via a push_back or via the constructor)
- vector is part of a number of data structures in the STL (Standard Template Library)
- look at C++ references on CS page
- look at the different STL library classes
- look at the vector class documentation
- many similar methods
- size
- insert
- some slightly renamed methods
- there is an "at" method, but it's not the same as get... more on this later
- notice that it's listed as a constructor
- more on this in a bit
- what is this "cout" business?
- made available because of "#include <iostream>"
- cout is an outputstream (similar to streams in Java)
- cout is the particular name for the stream that allows you to print to the console/terminal
- again, look at C++ documentation
- C++ Standard Library: Input/Output Stream Library
- if we scroll down, you can see "cout"
- "cout is an object of class ostream that represents the standard output stream"
- notice that it's just an object
- look at ostream class
- what do you think we'll find in this class?
- "operator<<"
- "performs an output operation on that stream"
- for cout, that means printing to the console
- notice that it has methods for many different types
- notice that it returns an ostream
- how does that help us?
- allows us to chain multiple << together
- back to the code... what does "cout << val << endl" do?
- prints value of val to the console
- prints "endl" to the console?
- endl is a variable for the "end of line"
- it's included with <iostream>
- filename is first.cpp?
- what are the filename restrictions in Java?
- class A, must be in A.java
- in C++, there are no naming restrictions. You can use one file, multiple files and the filenames do not matter
- by convention, when you have a class definition, you should put it in a filename with that same name .cpp

- what does max do?
- finds the maximum value in the vector
- looks almost identical to what we would write in Java
- what does simpleVersion() do?
- creates a new vector
- how many elements in it initially?
- 0, it uses the default constructor
- adds 1, 2 and 3 to the vector
- calls max, to get the maximum value
- prints out the maximum value to the console
- in this case, 5
- what does moreInteresting() do?
- again, creates a new vector
- creates a second vector nums2
- sets the first entry in nums to be 15 (rather than 1)
- calls max on nums2
- what do you think is output?
- two options:
- 3
- 15
- what would be output in Java?
- 15
- 3 is actually output
- what does this mean? why do you think this happens?
- nums and nums2 are different objects