CISC 3142
Programming Paradigms in C++
Introduction / Review

The Goals of this Course

To introduce you to software development in C++ and C
To explain the different programming styles (paradigms) in C++
To present the design philosophies of C++, C, and Java
To understand the syntax and semantics of the features of each language in terms of its philosophy
To continue your training in thinking logically and like a computer scientist/programmer.
Making you a C++ guru, or preparing you for a C++ certification exam, is NOT a goal of the course
- Helping you master the skill of looking at and understanding a programming language IS

Your Expected Background Coming into this Class

Courses in introductory and intermediate Java programming (CISC 1115, 3115)
- Python or some other language is fine; however, I will be contrasting primarily with Java
A course in data structures (3130)
A course in computer architecture (3310)
- C++ is derived from C — a low-level language — and part of its design decision was to provide low-level facilities; having some background in architecture will help understand those features.

What You Already Know

Based on your expected background, you should be familiar with the following topics. I've greyed out those topics that may not to have been covered in your courses; don't worry about those.

Program Structure and Development Environment

Editing, compiling, executing, testing and debugging
- You should be familiar with your Java development environment
- You should know the basics of testing your code: test cases, special/boundary conditions
- You should know how to debug your code using print diagnostics
compile-time, runtime
- In particular,
  - what happens at compile-time and run-time
  - the differences between compile-time and run-time errors
  - (the notion of the compile-time type of a variable vs the run-time type of an object)
    - This is more important in Java than in C++; however, it is really important in the general context of object-oriented programming

Imperative Programming

We will discuss this later — for the moment, think of imperative programming as the code/logic you write inside of a method: assignments, calculations, conditionals, iteration, calling of methods. Another way of thinking about it, it is the style/part of programming involving taking actions (e..g. Calculating and assigning statements, or calling methods), making decisions, and repetition.

Expressions
- operators, operands, terms, subexpressions
- arithmetic, boolean, logical, relational, conditional, assignment, compound assignment, casting, method invocation, field access, new
- unary, binary, ternary (? :)
- postfix, infix, prefix operators
- this
  - when this is necessary; what it refers to
Statements
- declarations - the role they play
- expression statement
  - this includes assignments, and method invocations
- conditionals: if, switch
  - you should be comfortable and know how and when to use cascaded and nested if/else's
- iteration: for, while, enhanced-for, break, continue
  - you should know the differences and appropriate and proper uses of the various iteration statements

Basic Classes and Objects

The class as a repository of state and behavior

A class as a template for the creation of objects; an object as an instance of a class
behavior (methods) vs state (variables)
instance/class(static) variables/methods
- You should understand the purpose of class variables and methods, and when they are used
Initialization
- Constructors
  - default
  - invoking an overloaded constructor in Java using this
- static block
- initialization at point of declaration
```
class C {
	…
	private int i = 17;
	private ArrayList<Integer> arrayList  = new ArrayList<>();
}
				
```

Methods

defining
message-passing
method invocation
method resolution
arguments, parameters,
return types and returning values
composition
receiver, this
overloading / overriding
get/set, accessor/mutator
high-level vs low-level methods & classes

Object-Oriented Programming

Encapsulation
- access control: public, private, protected, package protected
Inheritance and interfaces
- super/subclasses
- super in constructor and method invocations
- interfaces and abstract classes
- class and interface hierarchies
- implementing an interface
Polymorphism
- overriding
- down/upcasting
- ClassCastException
- compile-time/static type (of variable) vs runtime/dynamic type (of object)
- The Rule of Polymorphism
  - method resolution uses the (run-time/dynamic) type of the object, not the (compile-time / static) type of the reference variable
- compile-time (overloading) vs runtime polymorphism (overriding)

Types, Variables, Memory Model

primitive types, objects, reference variables
- You should know the differences between primitives and references
int, double, char, [], boolean, String
wrapper classes
- You should know the purpose of the wrapper classes
dynamic allocation (new)
arrays: 'resizing'
local vs instance variables
- You should know when locals and instance variables are created
final

Copy vs Reference Semantics

Deep vs shallow copy
Aliasing
clone

Input/Output

System.out, System.in, System.err
println
Opening, reading, writing, closing files
Scanner
Java's I/O model

Strings

+, equals, indexOf, substring, length, compareTo
- You should be able to programmatically manipulate strings, e.g. comparing, finding/removing blanks or other patterns, extracting words
- You should understand why strings are compared using equals and not ==
toString
- You should understand why and how every object has a toString method, and how it's used

Programming 'in the Large'

packages, classpaths, jars

Techniques & Algorithms

Maximum, minimum, average
Sorting, searching
Header, trailer, eof methods of input
Recursion

Data Structures

Containers / Collections
- array, vectors, stacks, queues
- linked lists, nodes
- trees, maps, sets
- hash tables
Operations: inserting, deleting, traversing

Quadratic (n² and log-linear (n log n) sorts

Basic understanding of the complexity of data structure operations and sorts

Exception Handling

you should know why, when, and how to use exceptions in your code
throwing, catching
try/catch blocks
The Exception hierarchy — (Throwable, Error, Exception)

CISC 3142 Programming Paradigms in C++ Introduction / Review