1. CS212 Programming-II for Engineers
Spring 2018

2. Topics
Basic Data Elements & Numeric arrays
More ADTs & functions, Intro to Complexity (Big O)
Linear list structures & recursion
Queues (using arrays)
Linked lists
Stacks & Queues with pointers
Prefix, postfix & infix notations
General Lists & Strings
Searching, binary trees & Big O again
C++ classes, objects, methods & "friends"
I/O, iostream, etc.
Sorting
Hashing
Trees (general)
Encoding & Compression (Huffman)
Graphs

3. Course Material Makefiles:
Syllabus and other course information available at:
dforeman.cs.binghamton.edu/~foreman
Makefiles:

4. Review makefiles from CS211. See links on previous page.
Some rules for CS212
This is primarily a course in Data Structures!
principles are language independent
We will be using C and a little C++
Platforms
Lab: Linux , Windows
Cygwin is NOT acceptable
Programs submitted must compile & run using the GNU compiler (g++) and (the MS compiler (cl) or Visual Studio)
Review makefiles from CS211. See links on previous page.

5. Some Course Goals Learn the use of common organizations of data in RAM
Learn to evaluate efficiency
memory space (RAM) needed for storage
Runtime using Big O
algorithms to manipulate the data
Learn to define, implement and use
Structured data types
Basic Abstract Data Types (ADTs)
Learn to use libraries of data structures
STL

6. ANSI C++ Compilers GNU compiler Microsoft Visual Studio
open source software from the Free Software Foundation
available on Bingsuns & labs in LNG103
built-in on most Linux systems
Cygwin is a Linux-like environment (including the GNU compiler) for Windows (sources.redhat.com/cygwin/) – UNACCEPTABLE!! (compatibility, timing)
Microsoft Visual Studio
integrated editor, compiler, linker, project manager (IDE)
installed on all Computer Center PCs and in Watson Microlab
free to students in Watson courses through the Watson-on-the-Hub (see Prof. Foreman's website for link)

7. Development Process Java is an interpreted language
C & C++ are compiled languages
Source code
Myprog.cpp
Source code
Myprog.java
Interpreter
Compiler
byte-code file
Myprog.class
Object Code file
Myprog.o
Executable file
Myprog.exe
CPU
MUST have interpreter to run Java pgm
CPU

8. Data + Algorithms = Programs
Every program processes data
Data is stored in memory (RAM) at run-time
Java, C, C++ are strongly typed languages
all data items have a type associated with them
Data to be processed must be declared as data objects (variables) using this syntax (for C, C+++ & Java):
type name;
type name = value;
Type of a data object determines
Allowable operations (+ - * / etc.)
how data is represented in memory (integer, float, etc.)

9. .... Program structure – pt 1 -preprocessor directives
(control compilation)
(include header files}
-global declarations
(constants and types only!)
-function prototypes
(names & parameters only)
myProg.c or myProg.cpp
main f1
....
function definitions
(implementations) fn

10. compile / link / execute
Myprog.c Yourprog.c
#include “myinfo.h” #include “myinfo.h”
object's functions
Myprog.o Yourprog.o
Ourpgm.exe
(a.out is a default name in Linux)

11. Compiler Commands compile only Link 2 units execute compile & link
gcc -c Myprog.c
produces Myprog.o
gcc -c Yourprog.c
produces Yourprog.o
compile
only
gcc -o Ourpgm Myprog.o Yourprog.o
produces Ourpgm
Link 2 units
./Ourpgm
executes the program
execute
compile
& link
gcc Myprog.c
produces a.out
Cl Myprog.c
produces Myprog.exe

12. Types Pre-defined (built-in) types
scalar (atomic) types – store a single value
int
char
float, double
bool
structured types – store a collection of values
Most languages have libraries of types
STL for C and C++
Java library
Programmer-defined types
create new "types" appropriate for your problem
built from pre-defined types

13. Types - 2 defined at compile time (how??) A char is USUALLY 8 bits
Size off an int is 8, 16, 32 or 64 bits
Size of float/double
A char is USUALLY 8 bits
Has a numeric value 0-255
Usually represents a printable symbol
Some embedded systems may have 16 bit char's
Arithmetic with a char is invalid (e.g.; char+char)
A bool is a single T/F value –
stored as a whole byte(?) - Compiler defined

14. typedef Allows using the name of an element as a datatype
Does NOT reserve space for the element!!!
(i.e.; the typedef statement uses no memory)

15. Types - 3 uint8_t is a typedef for unsigned char Why use this typedef?
Indicates intent – you will do math with the element.
Char is printable data in range (decimal)
0-31 and are for other uses
but all 256 values are legal for math
Examples:
unsigned char i, x='a', y=0x01; i=x+y; // unclear
uint8_t x='a', y=0x01; i=x+y // is clear.
(both output 'b' as the value of i)

16. DataTypes Composite Types array struct union class void pointer
Structured Types
array
struct
union
class
Scalar Types
Arithmetic
void
pointer
priority_queue
valarray
vector
deque
list
set
map
multiset
multimap
stack
queue
string
bitset
istream
ostream
iostream
ifstream
ofstream
fstream
C++ Standard
Library classes
Integral
Floating point
bool
complex
(reals)
Characters
float
double
long double
Enumerations
Integers
int
short int
long int
unsigned
short unsigned
long unsigned
char
unsigned char
signed char

17. C vs. C++ C++ is a superset of C Any C program is a valid C++ program
allows ALL of C syntax
adds NEW syntax for
objects
I/O streams
namespaces
Any C program is a valid C++ program
even if it does not use any of the ++ syntax
Some compilers know by the file extension (MS)
Others require specific compiler (gcc vs. g++)

18. namespaces (C & C++)
"namespaces" allow you to assign portions of your program to different namespaces
variable names are local so they may be reused in a program as long as the uses are in different namespaces
using namespace std;
the namespace “std” is a little special
you don’t have to specify the “.h” for all standard #includes
e.g.; #include <iostream> #include <iomanip>

19. Composite data types – C arrays
One name for a collection of items
Subscripted (as in standard math notation)
X3 is represented as X[3]
There are no subscript keys on a keyboard!
Multiple values
X[0], X[1], etc.
All elements are same type and size
Max # elements must be a constant (in C, C++, Java) (for non-dynamic arrays)
int x[20];
float y[2012];

20. Arrays - 2
int X[5]; x[3]=17;
X[0]
X[1]
X[2]
X[3]
X[4] 17
X[0]

21. Arrays - 3 C does not have an "array" data type
C uses a simple variable with subscript notation: int x[5]; // BUT
max subscript value in definition must be a constant
int x[y]; // is ILLEGAL, even if y has a fixed value
all arrays start at element 0
above is x[0] … x[4]
C allows multi-dimensioned arrays (like Xijk)
int y[3][4][2]; y[0][2][1]=17;

22. Arrays - 4 compiler might not detect it!!!!!
compiler ALWAYS reserves memory for the ENTIRE array, whether it is used or not
arrays may be ANY data type, including structs
no protection on accessing beyond real size
int x[5]; x[5]=3; // ERROR at RUNTIME
compiler might not detect it!!!!!
the array has 5 items, numbered 0-4
int j; scanf("enter j%i",j); x[j]=3;
compiler CANNOT detect it!!!!!

23. Composite data types - more
"struct" – a simple collection of items
"union" – multiple types for the same RAM starting location
union {char a,b,c,d; int X;}
"a" is the leftmost byte of "X"
"class" – data + functions that operate on it
this is in C++, later in course
All allow collections of dissimilar types

24. struct's A way to combine basic elements Complex numbers
Create collections of elements
Treat them separately AND/OR as a collection
Use them to create more complex elements
Complex numbers
Real part
Imaginary part

25. struct's – an example pt 1
struct Complx {float my_real_part; float my_imag_part; }; // note the semicolon!!!!! Creates a structured variable named Complx

26. struct's – an example pt 2
typedef struct Complx {float my_real_part; float my_imag_part; }; // note the semicolon!!!!! Creates a datatype named Complx Complx c; // "c" now refers to BOTH parts c.my_real_part=5.2; c.my_imag_part=3.6; // this is equivalent to j

27. Pointers a pointer is a memory address (points to some data)
lets you refer to data without the data's name
int x[5] ; // this takes up 20 bytes 5*(4 bytes/int)
int *z; // z is a pointer to an int and is 4 bytes
int (*y)[5]; // uses only 4 bytes
y is a pointer to an array of 5 ints
y=&x; // y now points at X (≠ X)
z=&x[3]; // z now points to x[3] (has x[3]'s address)
// z does not EQUAL the value in X[3]
int *P[8]; // array of 8 "pointers to int's" (8*4bytes) NOT the integers themselves!!!!!!

28. Dynamic allocation Often need to make space at runtime
Size/amount of data not pre-defined
Data may need to be ordered by some rule (e.g.; "<")
Complx *p; // defines ONLY the POINTER, p
// only a “promise” that p will point to a Complex
p=new Complx; //reserves RAM, p now points to it
p->my_real_part=3.5; p->my_imag_part=5.6;
Note use of pointer notation vs. member notation
// equivalent to j

29. Abstract Data Types (ADTs)
Collection of data items + operations for it
Independent of programming language
2 parts:
Definition – of data and operations allowed
Implementation – how data is stored and algorithms to carry out the operations
User –
uses the ADT to solve a problem;
doesn't need to know the implementation details
Needs to know the syntax rules for the ADT

30. The Basic Concept
An ADT encapsulates data and the operations on that data.
The data can be accessed
only via the operations & operators.
Operations
(methods)
data

31. ADT vs. Class ADT: a model of data AND its related functions
C++ Class: a syntactical & programmatic element for describing how the functions and data are related
An ADT implementation has several parts:
interface function-names (methods)
operators (possibly re-defined symbols)
data
Any/all of these may be public or private

32. ADTs – example revisited
struct Complx
{ float my_real_part;
float my_imag_part;
}; // note the semicolon!!!!!
All elements "visible”. Reserves storage
NOT a new “type”
Complx C; // reserves storage.
Complx_init(&C, 2.5, 3); // prototype
void Complx_init(Complx *C, float rr, float ii ) {
C->my_real_part = rr; //note the pointers!!
C->my_imag_part = ii; }

33. C++ console (terminal) I/O
#include <iostream>
basic operators
<< the "insertion" operator
>> the "extraction" operator
stream names for standard I/O
cin is the input "file"
cout is the output "file"
usage
cin>>x; // get a value
cout<<x; // output a value

34. Operators New objects (structs, classes) may need more
Ordinary variables have basic operators built-in
+ - * / % | & || &&
New objects (structs, classes) may need more
How do you "add" 2 complex numbers?
Given: complex#'s a and b;
what does a+b mean???
compiler knows nothing about complex #'s
Define a NEW action (function) to perform "+"
add the real parts, add the imaginary parts
store each result in the proper answer-part.

35. Example – Declare the functions
typedef struct Complx { float my_real_part, my_imag_part; }; // below could be member function prototypes float Complx_get_real(return my_real_part); void Complx_init(set both parts); Complx Complx_add(add 2 complexes); // for this slide and following slides: // blue: declare the structure, green: use it, red: return-value type

36. Example- implementation
// no automatic functions for initialization Complx x; // allocate memory for x as a struct Complx_init(Complx *x, float a, float b) { x->my_real_part=a; // note the -> notation // because x is a pointer to a Complx x->my_imag_part=b; } Complx Complx_add (Complx* a, Complx* b) {Complx tmp; // need a place for output // "tmp" is NOT a pointer-based variable, "a" and "b" are // so note differences in use of “.” and “->” tmp.my_real_part = a->my_real_part + b->my_real_part; tmp.my_imag_part = a->my_imag_part + b->my_imag_part; return tmp;

37. Example-pt 2
void Complx_init (Complx *, float, float); void main() { Complx A, B, C; Complx_init (&A,2,2); Complx_init (&B,1,1); C=Complx_add(&A, &B); printf("C=%d+%dj",C.myreal_part, C.my_imag_part); }

38. Program structure – 2
Usually, put the struct definition in a header file
#include it later in BOTH :
the implementation file
where the methods are defined
the user-program file
where methods get used