CSE 240 Ch 2

Formatted C++ input/output

'using namespace std' for C++ I/O, '#include <iostream>' for C-style I/O in C++, cin >> i (input an integer), cout << "i = " << i (<< endl)

char *p = "send me your password", *q;

*p creates a string constant and pointer *q is also a constant, pointer pointed at constant acts as constnat(slide 5 pointers, arrays, strings is confusing)

long int

+- 2,147,483,647 ; 32 bits

char

-127 to 127 or 0 to 255, 8 bits

signed char

-127 to 127, 8 bits

int

-32,768 to 32,767 ; 16 bits

short int

-32,768 to 32,767 ; 16 bits

pointer notation

->, pointer to structure (in Java the [obj].value is pointer)

byte

0 to 255, 8 bits

unsigned char

0 to 255, 8 bits

unsigned long int

0 to 4,294,967,295 ; 32 bits

unsigned int

0 to 65,535, 16 bits

in-class exercise answers

1) b 2) a 3) a 4) d 5) c (slides on Bb)

when you declare an array, which is valid? 1) const int max = 20; char a[max]; 2) #define max 20 char b[max];

1) does not work in visual studio 2) works in all environments

fantastic four abstract approach

1. Formulate the size-n problem 2. Find the stopping condition and the corresponding return value 3. Formulate the size-m problem (m < n) and find m [often m = n-1] 4. Construct the solution of size-n problem from size-m problem (similar to induction)

double

10 decimal digits of precision, 64 bits

long double

10 decimal digits of precision, 64 bits

decimal

128 bits

String

16 bits each

Merge sort

2 recursive calls,

functions (Components of C/C++)

2 types: built-in (pre-written in libraries) and user defined functions ; may exist outside of class (global, also global variables) ; each program must contain one main() function (outside of any class)

sorting algorithms

2.8 in textbook

2D array of string in C

3D array, each element is is a pointer, 3 levels of for loops to navigate char by char (can use strlen in innermost loop) OR get initial address of each strings and print that point as a string OR increment with pointer of pointer for each string

Assume this is a 32-bit environment, given a declaration: int a[10]; What is the size (in bytes) of the entire array?

40

float

6 decimal digits of precision, 32 bits

Registers

D-flip flops, 32 registers at 32 bits each, 50-200ps(access time)

Main Memory

DRAM, 16GB, 50-70ns, $20-$75/GB

mutually recursive function

F calls G, G calls F ; does not allow declaration before use, Forward declaration puts ex)void bar(void); to show signature, I/O type, don't have to worry about order of functions

Buffer maps

I don't really get it, buffer is a queue structure, \n turns into \0

pointers are

IMPORTANT

Secondary storage

Magnetic Disk, 2TB, 5-20ms, $0.20-$2/GB

in class exercise

Q1: ? Q2: when there is one node only, when list is empty (head and tail point to same node), Q3: the first node, Q4: no, case 3 is not included because you have to set the tail pointer, Q5: C, both their nodes contain two pointers to their own types

Cache

SRAM, 0.5GB, 0.5-2.5ns, $200-$500/GB

Given the C declaration: char s1[4], s2[ ] = "hello"; if a string copy function strcpy(s1, s2) is executed, what will happen?

The result s1 will contain the string "hell", and the following two byte loactions will contain 'o' and '\0'.

Variables and library allegory

Value stored (book), Location (place book stored on bookshelf), address(numbers for where book and shelf are located), name (name of the bookshelf)

endl

\n in C++

tree

a graph without a loop and one path between each pair of nodes, height is number of edges from root, root to farthest leaf

char s1[] = {'a', 'l', 'p', 'h', 'a'}; in memory

a l p h a ; size = 5

char s2[] = "alpha"; in memory

a l p h a \0 ; size = 6

function purpose

abstraction and reuse

Pointers in C/C++

address can be assigned to pointer, address stored in pointer can be modified, & Referencing (get address of variable from its name), * Dereferencing (create a variable name for a given address)

what is a program

algorithm (steps of data manipulation, emphasized by imperative) and data (object of manipulation)

binary tree search

also recursive

pointer memory space

always 4 bytes

pointer size in memory

always 4 bytes

L-value

an expression with a location associated with it, can occur on left or right side of an assignment

r-value

an expression with a value but no location associated with it, can only appear on the right side of an assignment

binary tree

any node can have at most 2 next nodes (child nodes), linked list is a tree, binary tree

midterm

be able too identify recursive steps, write own recursive function, 13 multiple choice, review slides, 20 pts. writing questions, answer questions by code given, write small pieces of code, go to UGTA review session

C++ types

bool (boolean), wchar_t(wide-character, 2 bytes = 16 bits), char, int, float, double, void

Buffer in file system

buffer is an invisible array of bytes or characters, use (C: scanf, getc, putc, fflush) or (C++: cin, cout, cin.get, cin.getline, cin.ignore)

linked list

build node in struct containing pointer to next (ex: struct contact *next), first struct is declared with pointer (ex: *head = NULL;), a graph

passing a structure into a function

call by pointer(*y parameter) creates new address, call by value(y parameter) uses same address

call-by-address vs. call-by-alias

call-by-address(call-by-pointer) has formal parameter hold address as variable, but in call-by-alias(call-by-variable) has formal parameter hold same variable, does not pass in value, but only variable

2D array of chars

can be treated as a 1-D array of strings

fantastic four step 3

challenging step, reduce problem by one iteration, m may be n-1, but by specific application may be something else [ex: factorial(n-1);], do not try to solve problem, assume the return value will be able to solve the problem[ex:n*factorial(n-1);]

%c

char

types in C

char (1 byte=8 bits), int, float, double, void

passing string address using pointer

char *getString(char *str)

truncated initialization

char s2[4] = "alpha" ; -> a l p h ; size = 4

fantastic four step 2

check stopping condition first, then enter recursion, often stopping condition and corresponding value is trivial

unformatted C++

cin.getline() to get input with a space, cin.getline(destination, size, terminationChar); <- enter characters to size or enter terminationChar to end input, always terminates on enter

flush buffer

cin.ignore() or fflush(stdin)

functions

communicate with rest of the code using global/static variables, but more often parameters/return values

constants in C/C++

compiler may substitute values for constant definitions - constant defined as a macro (#define max 20, not modifiable), constant may be a variable that the program cannot modify - has to read memory, so slower, declared as const int i; i = i + 2; will cause a compilation error

linked list functions: search()

create as a struct, create local variable stack, 2 pointers, find target with bigger(first) pointer and return smaller(second) pointer

search in linked list

create new pointer at beginning, and another behind it, compare what is at the 2 pointers. Earliest (2nd) pointer is used for insertion and deletion, as we can not refer back with linked list

linked list insertion to arbitrary position

create pointer to certain node, then do insertion operations fro that node instead of head

data declaration

declaration binds name to location and gives type, scope, and qualifier of the value to the location

free(t);

delete piece of memory assigned by malloc where t is a temporary pointer, not using it leads to memory leak

deleting an entire linked list

delete step-wise with while loop(move temp pointer, then delete head, then set head to temp) or recursively

*

dereferencing, giving name, can be on both sides, (l-value), unary, returns an l-value

pointer extra practice

do some!

memory is byte-addressable

each byte has its own address, address of int, float, and pointer must be multiples of 4

fgets (unformatted C-style)

enter string with spaces (can't use spaces with scanf), formating ex: fgets(variable *destination, size, file type *source), fgets(name, sizeofName, stdin) <- stdin reads keyboard input and stores it in name

Google Big Table

extended binary search tree, B+ tree, keeps sorted data, all records stored in leaves, insert with red-black tree for balance

fantastic four step 1

find n for number of iterations, often use n as parameter [ex: int factorial(int n)], return value will be what we are looking for

sizeof

find number of bytes used

insertion algorithm in binary search tree

first number as root, smaller to left, larger to right; worst case input is sorted and forms linked list O(n), typically unbalanced tree O(n); can restructure tree to be balanced with every insertion Olog(n)

%f, %5.2f

floating point number, have 5 digits and 2 decimal places

formal and actual parameters

formal parameter is local variables in the function, actual parameters are the actual variable/values

C input/output (C-Style)

formatted: printf(); and scanf(); included through #include <stdio.h> (input/output library), scanf("%d", &i) <- '&' means taking address as input (a pointer), not name, printf("i = %d, n = %d\n", i, n) <- in this case want the value of i and n

industry application: amazon.com recommendation list

frequently bought together items are made automatically

imperative paradigm

fully specified and fully controlled manipulation of data step by step, abstraction of store program concept, algorithmic, popular for good performance(efficiency b/c works like the computer) and step by step system(familiar)

when using an array, in a loop a-- will...

go to the previous value of array, regardless of type

modules and packages

group programs to make a library,

full binary tree

has each node with 2 or 0

pointer and unsigned int type

have the same data range (0 to 2^32 -1), both support + and - operations, pointer does not support * and /; C/C++ supports coercion and casting between the 2 types as it makes sense.

%x

hexadecimal number

Delete node at arbitrary position

if node is first(head = head->next;), if node is in middle (b->next = p->next; where pointer p is one node ahead of pointer b);, if node is at end, use search to find pointer to proceeding node(b->next =0;)[this case is unnecessary], in all cases use free(t); to delete piece of memory

*(p++)

increment address first, then access

Arrays in C/C++

individual elements accessed by index, string is array of characters

the name of the array is the initial address of the array

int x = 5, *xptr; int y[10], *yptr; xptr = &x; yptr = y; yptr = &y[0]; 2D array: char ma[4][8]; ptr = &ma[0][0];

Pointer

is a variable, gives an address a name, has data (location address), location(in memory), address (number of memory location), name (name for location, &name refers to address of location)

The imperative programming paradigm is popular and is a part of object-oriented computing paradigm, because it ____ (Select all answers that apply).

is based on computer organization and thus is efficient to execute on hardware. AND matches the culture of doing things by following the step-wise instructions.

int *j = 0 means...

j is set to 0

balanced binary tree

leaf nodes can only differ by one level, fast search (more than other binary trees) O(logn)

postorder traversal

left-right-root

Inorder traversal

left-root-right

struct (structure)

like a class in java, but without methods; struct person { char name[30]; long phone; char id[12]; } p;

(int*) malloc (40);

like keyword new(); in Java, stands for memory allocation, in this case 40 consecutive bytes cast for storing ints, new int[40]; in C++

linked list vs array

linked list has structs without consecutive memory connected by a pointer while array is all consecutive, linked list gets memory as needed, array gets memory all at once, array memory can come from static,stack,or heap, while linked list is always heap(malloc)

shortest and simplest program

main () {}

main()

main can take arguments and specify output, ex: double main (int argc, char a) { ...; return...}

make own library

make a c file (wind 32 project DLL) myLib.c, put global variables and functions in, make header file myLib.h to hold forward declarations, in a separate file just #include "myLib.h"

recursion is important for 310

make sure you understand

search speed is _____ important than insertion speed

more

graph

more than one next node allowed

applying fantastic four

multiple examples in slides, insertion sort

function/procedure/subroutine

named block of code the must be explicitly called

\0

null terminator (null character), automatically added to the end of a string

binary search tree

number in each node, ordered

recursion

only deal with 1st and last step (all middle is handled by recursion), only necessary if wee need to repeat the same operations a number of times

char *p

p ->

parameter passing

pass actual parameters to formal parameters, most use call-by-value: formal parameter is initialized to value of actual parameter (no side-effects, less flexible/powerful/efficient), call-by-address: formal parameter is a pointer to actual parameter, call-by-alias: formal parameter is alias of actual parameter, refer to same memory(only in C++), also global variable/static variable and call-by-name

copy array size 7 to size 6

places extra in memory somewhere, does not give an error (semantic)

to access members of linked list structure

pointer = malloc(sizeOf(struct contact)); [to get proper amount of memory to hold structure with pointer, struct obj. has no name] scanf("%s", p->name); scanf("%d", &p->phone); scanf("%s", (*p).email);

pointer to manipulate 2D array

pointer has its own memory address and value, store memory address of first element in pointer value (*p is value in address), need to know ASCII code of values (ex: '\0' is 0)

use pointer to navigate array

pointer is faster than using numbers with initial element of array + change; more consecutively, not from beginning everytime

HW 7/8: print forward/backward

print first in recursive call, print backward put print second at end of recursive call

char q[ ] = "morning"

q= "morning"

&

referencing memory, on right side only(r-value), returns r-value, unary operator

Data in imperative paradigm

represented by states (variables and values), type, location (where data stored in memory), address (integer associated with location), reference/pointer (name associated with the variable holding the address), name, value , scope (lifetime) and visibility

preorder traversal

root-left-right

char *s = "hello"

s -> "hello"

signed int

same as int, 16 bits

signed long int

same as long int, 32 bits

signed short int

same as short int, 16 bits

unsigned short int

same as unsigned int, 16 bits

wchar_t

same as unsigned int, 16 bits

scope rule

scope of a variable starts at declaration point and extends to the end of current braces, need to be declared before use

C/C++ modifiers

signed, unsigned, short, long

%d

specify integer type

%s

string

printf("%s", array) will print

string of array, excluding the null terminator

array of structures (slide 63)

struct contact { char name[30]; int phone; char email[30]; } struct contact contactbook[max]; int tail = 0; //methods void branching(char c); int insertion(); int search(); int delete();

cin.ignore()

switch from cin>> to cin.get or cin.getline, cin>> leaves delimiter inn buffer, can flush a certain number of characters (cin.ignore(int n)) or number of characters or stop at a certain char (cin.ignore(int n, char term))

t = (int*) malloc (40); t[0] = 5;

t can be treated as array by memory allocation

What is NOT the purpose (functionality) of the forward declaration (prototype)?

to allow a function to return different types of values

pointer vs memory incrementation

to increment pointer use p++, to increment what is in pointer current address use *p = *p + 1

C/C++ allows direct access to memory address

true, can still use name if wanted & available

bool

true/false, 1,8 bits

type construction and enum

typedef enum {false, true} boolean; boolean x = false;

typedef

typedef typename newname; makes a new name that becomes a synonym for the type of typename ex) typedef char FlagType; FlagType x = '10';

switching from unformatted to formatted

unformatted input leaves a '\n' in the input buffer and needs to be flushed by fflush()/getchar()/cin.ignore() before using formatted input

linked list operation: insertion

use local pointer(*p), then make temp object (p = (cast) malloc(sizeof(struct [name])); Then get entries, then insert next link at beginning(p->next = head; head = p;)

fantastic four step 4

use size-m solution to construct size-n problem, this step is application-specific, sometimes we need the return values of multiple size-m problems

fflush(stdin)

use to remove delimiter before using getc(stdin) or getchar(stdin), as scanf leaves delimiter in buffer

const int i

variable with memory allocated, use & function to find address, compilation error if you try to modify, if you go around the compiler it can be modified but that is bad practice