CS62 - Spring 2011 - Lecture 32
- Professor Kauchak's office hour changes this week
- today: moved to 4-5:30
- Thursday: 1-3
- Assignment 10
- use the documentation
- private methods
- key vs. priority
- download Aquamacs (
) for file editing
- install xcode (this should be included with your original install disk or you can download from Apple, but there may be a small fee)
- download Emacs (
- For the compiler, there are two options:
which is a command-line utility. When you install, make sure to include the C/C++ packages.
which has a basic command-line and the compiler
Question: What happens in Java when you have two things in the namespace called the same thing?
- There is ambiguity and so the compiler forces you to use the full package names, e.g.
Compiling multiple files: look at
- header file with a few more declarations
- none of the examples here have private methods, but you can also declare those in the header file
- method definitions
- again, notice that the private variables only occur in the header file
- notice we put the main method in another class
- straightforward use of the class
- notice again the calls to the constructor
- we now have multiple class files that we want to compile
- can't just do it with one line
- C++ has three main steps in compiling
- compile to machine code
- link all of the machine code files into one project
- preprocessing happens automatically when compiling
- need to compile each .cpp file individually
g++ -c bankaccount.cpp
g++ -c bankaccountest.cpp
- the lines above could be done in either order, why?
g++ -o bank bankaccount.o bankaccountest.o
- link all of the files together and make a binary
- binary is called bank
- you can get "link" errors if, for example, you haven't defined a method that you said you would
- why don't we have to compile the header files?
- they get #included and implicitly compiled. You can get compiler errors in header files
pointers (reference in C++)
- in Java, we have two high-level types of variables
- built-in types
- references to objects
- (and really arrays as a third type)
- what do you think a reference actually is, i.e. how is represented in memory?
- a reference is just a memory address
- traditionally, a memory address was represented as 32 bits
- so an object variable uses up 32 bits
- how much memory can you address with 32 bits?
- 2^32 different numbers = ~4 billion numbers
- each number represents a byte
- 4 gigabytes
- my mac has 4 GB of ram, do you think this is a coincidence?
- again, traditionally, memory was accessible by 32 bits
- traditionally, most processors operated in 32 bits
- what is a 64 bit processor?
- it's a processor that operates memory addresses on 64 bits
- what is the advantage?
- much bigger memory space
- if we only need 1G of memory, we're going to waste space because references now take up twice as much space
- you will hear people talk about 32 JVM vs. 64 bit JVM
- since java is a "virtual machine" it can have either 32 bit or 64 bit addresses
- in C++, we have three variable types. We've seen two. What are they?
- built-in types
- object variables on the stack
- (and again, we also have arrays)
- the third general type are "pointers" or "pointer variables" (similar to references)
- Like Java references
- a pointer is a variable that stores a memory address
- a pointer can only point at an object of that type (more or less)
- Unlike Java references
- not all object variables are pointer variables (as we saw last time)
vector<int> v; // is not a pointer/reference
- to distinguish, we put a '*' after the type indicates that variable is a pointer variable rather than a traditional variable
- unlike Java, we can have pointers to built-in types as well as objects
- A few examples:
- Using pointers
- Like Java, we can use the "new" command to create a new object
- where do you think this is stored? On the heap!
vector<int>* vPtr = new vector<int>; //
the "new" command returns the address of the newly created object
- notice that:
vector<int> v = new vector<int>; // will NOT work
- different types
- the new command will return a vector<int> pointer
- you're trying to assign it to a vector<int> variable
"conversion from ‘std::vector<int, std::allocator<int> >*’ to non-scalar type ‘std::vector<int, std::allocator<int> >’ requested"
- A pointer is just a memory address (the type is for type checking by the compiler)
- Because it is just a memory address, you use them slightly differently than a normal variable. To access the data that the variable "points" to, you need to "dereference" the pointer.
- "dereferencing a pointer": Given a pointer: vector<int>* vPtr;
- you can dereference the pointer again using the '*' operator and then use methods using '.':
- you can use the '->' operator (which is generally preferred):
- look at
- what does objectPointer do?
- creates a new int vector
- where is it created? on the heap
- for the default constructor, you can either include or not include the parenthesis
- adds the numbers 0 through 9 into the vector (note the use of (*v) to dereference the pointer
- prints out the numbers
- what will be printed out?
- remember, a pointer is just an address. The cout statements printing v, will just print the memory address where the object is stored
- will this change during the method call?
- no, we never assign anything different to it so it won't change
- all the address print statements will print the same address
- what does objectPointersBetterApproach do?
- same thing, however, we're using the "->" operator rather than dereferencing the pointer
- in general, a better approach
- There are two ways to get a memory address (i.e. the value for a pointer)
- using "new", that is an address on the heap (like we've seen)
- you can get the address of any variable using the '&', "address-of" operator
vector<int>* vPtr = &v;
int x = 10;
int* xPtr = &x;
- look at
- what will be printed out by the objectPointers2 method?
- 10, 20
- vPtr is just a pointer to vec, so the push_back calls push values onto vec
- where is vec stored?
- on the call-stack! (remember this...)
- if you play with these programs you'll actually notice a difference
- when we printed out the address above on the heap it was something like:
- here, when we print out the address on the stack it's at:
- which are not very close to each other!
- what will be printed out by the address method?
- the address of x, again on the call-stack
- 10, which is just the value of x
- notice that even though x is a built-in type, we can point to it
- when we dereference a built-in pointer, we just get the value (just like for object pointers we got the object)
- in general, most of the time, you don't use pointers to built-in types, just objects
- what will be printed out by the changingValue method?
- The address doesn't change
- print out 11