This list is intended to remind you of the terms and concepts you are expected to understand, from lecture and from section. Where are there are no definitions here? Because (a) this list is meant to aid you in reviewing more than learning, (b) definitions can be found in the lecture slides and/or textbook, and (c) I just don't have time to rewrite or copy them here. This does not mean that you aren't allowed to ask me what these mean, either directly or via the anonymous feedback form. You are always welcome to ask me questions.
There are many terms and concepts you're expected to know from back in CSE 142. I'll put them here in this first section as we encounter them throughout the quarter.
variable declaration, initialization type Boolean (bool) constants pointer dereference function declaration (also, prototype), definition, call parameter formal, actual parameters pass by value, by reference struct field loop iteration conditional
module, modularity functional decomposition source, header files preprocessing, compiling, linking object files, executable standard library stub, driver debugging execution flow (also, flow of control, control flow) invariants preconditions, postconditions loop invariants assertions (assert())
abstraction abstract data type data, operations interface vs. implementation client vs. implementer header vs. source file (review) type/class vs. instance (also, object) class member variable (also, member data) vs. member function (also, method) public vs. private "call a method on an object" constructor default constructor
I/O stream standard input standard output, standard error operators << (insertion, must have an ostream before it) >> (extraction, must have an istream before it)
ADT vector (list) ADT data representation recursion recur (not recurse) base case(s) vs. recursive case(s) binary search log (base 2) tracing function calls activation record
allocate vs. deallocate static vs. local/automatic vs. dynamic memory local scope (review) activation record (review) operators: new, delete heap memory memory leak dangling pointer static call graph
(singly) linked list linked list node (has a next ptr.)
const const method const parameter const variable destructor copy constructor operator= (assignment operator) operator overloading
stack ADT push top pop queue ADT enqueue dequeue
is-a vs. has-a relationship is-a-kind-of vs. is-an-instance-of class inheritance == subclassing class hierarchy, hierarchical relationships superclass vs. subclass == base class vs. derived class method overriding (vs. overloading) public vs. protected vs. private initializer list
static vs. dynamic static == determined at compile time dynamic == determined at run time dispatching dynamic dispatching == late binding virtual method declaration
virtual destructor abstract vs. concrete class recall: interface vs. implementation pure virtual function
function scope is a kind of block scope
block vs. class scope
shadowing (e.g. "shadowing a variable")
overloading
resolving (e.g. "resolving a method call")
operator, binary vs. unary
operator overload
operator vs. operand
concatenation (e.g. of lists)
algorithm
running time
constant, O(1)
log, O(log n)
linear, O(n)
polynomial, O(nk)
quadratic, O(n2)
cubic, O(n3)
exponential, O(kO(n))
complexity function
asymptotic complexity
"big O" notation
insertion sort quicksort partition pivot median selection sort
in-place sorting tree node == vertex edge root (node) internal node vs. leaf (node) child (node) vs. parent (node) descendant vs. ancestor subtree height (of a tree) binary tree
traversal pre-, in-, post-order binary search tree
Table ADT == Map == Dictionary retrieve insert delete key vs. value hash table hash function collision