CSA150 Course Reader

1. Introduction to C++

A-An Overview of C++

An Overview of C++The C++ Programming Language Hello World Source Code Program Mechanics The Build Process

B-The C++ Back Story

Early Computing Machine Language High-Level Languages The C Language Object-Oriented Programming The C++ Language

C-Syntax Basics

C++ Syntax The f2c Program The Standard C++ Library The main Function The convert Function

D-Variables & Values

Variables Definitions & Types Identifiers & Constants Initialization Assignment Console Output Console Input

E-Numbers & Calculations

Integers Signed & Unsigned Integer Literals Floating-point Numbers Floating-point Output Expressions Expression Evaluation

2. Functions, Decisions & Strings

A-Side-Effect Operators

Integer Division & Remainders Assignment Operators Increment and Decrement Mixed-type Expressions Type Casts Functions The <cmath > Header

B-Functions & Decomposition

Writing Functions Function Syntax The Function Body Functional Decomposition Declaring & Defining

C-Making Decisions

Making Decisions Blocks, Style & Indentation The bool Data Type The Relational Operatorrs The Logical Operators Multi-way Branching Nested if Statements

D-C++ Strings

Creating String Object String Input and Output Concatenation & Comparison Mutability & Value Assignment Member Functions

E-Processing Strings

String Members Characters Selecting Characters Substrings Searching a String

4. Function Libraries

A-Library Mechanics

Library Mechanics Separate Compilation The Client or Test Program The Interface or Header File Adding the Prototypes Library Types in Interfaces The Implementation File Stubbing the Implementation The Make File

B-Documentation & Implementation

Documenting the Interface Planning & Implementation The while Loop Limit Bounds Running Doxygen

C-Overloading & Default Arguments

Overloaded Functions Overload Resolution Default Arguments Default Argument Rules

D-Data Flows

Data Flows Output Parameters Input and Output Parameters Input-Output Parameters Data Flow Checklists

E-More Selections & Iteration

More Selections & Iteration The switch Statement More on switch The Conditional Operator A Hasty Loop Confirmation Loops

5. Recursion, Streams & Filters

A-Introducing Recursion

Introducing Recursion The Factorial Function A Recursive Example The Recursive Leap of Faith The Fibonacci Sequence Recursive Efficiency

B-Efficient Recursion

Efficient Recursion Wrappers & Helpers Checking Palindromes Palindrome Efficiency

C-Applying Recursion

A Recursion Checklist I A Recursion Checklist II Code Step-by-Step Solving the Problem I Solving the Problem II

D-Streams & Redirection

The Standard Streams The cat Filter Input Redirection Output Redirection Error Redirection Pipes & Pipelines Built-in Filters

E-Filters

Process Filters State Filters Your First Filter Data Loops More on Streams

6. Files, String Streams & Errors

A-Processing Files

The Stream Classes UML Diagrams Easy File I/O Processing Lines Processing Tokens

B-Validating Data

Applied File I/O Stub the Function Searching & Numbering Validating Data

C-String Streams

String Streams The format Function Input String Streams An Input Stream Exercise The Arguments The Longest Line Counting the Lines Processing the Tokens

D-Conditional Compilation

Conversion Functions Using the Functions Stub the Replacements Using #define Conditional Compilation Predefined Symbols Comparing the Results

E-Errors & Assertions

Handling Errors The Terminator Using assert More Assertions Completion Codes Error Flags

7. Exceptions, Templates & Structures

A-Exception Handling

Exception Handling Throwing Exceptions What Should You Throw?The try and catch Blocks Other catch Blocks

B-Templates

The to_string Functions Function Templates Template Instantiation Template Argument Deduction Multiple Template Arguments Explicit Template Arguments Inferred Return Types Templates & Overloading

C-Structured Types

Structured Types Structure Definitions Structure Variables Initialization Member Access Aggregate Operations

D-Structures & Functions

Structure Arguments By-Value or By-Reference A Compare Function Returning Structures Structured Bindings

E-Enumerated Types

Enumerated Types Defining Enumerated Types Enumerated Variables Enumerated Output Enumerated Input

8. Vectors, Memory, Pointers & Graphics

A-The vector Type

Why Vectors?Meet the vector Vector Variables Vector Initialization Element Access Range Checking

B-Processing Vectors

Growing & Shrinking Vectors & Loops Common Algorithms Counting Algorithms Cumulative Algorithms Extreme Values Modifying Algorithms Filling & Shuffling Vectors & Functions

C-Memory & Addresses

Memory & Addresses Naming Concepts Global Variables Local Variables Characteristics of Variables The sizeof Operator The Address Operator

D-Pointers

Pointers Defining Pointers Initializing Pointers Dereferencing Pointers Pointer Assignment The "null" Pointer

E-Pointers & Graphics

Digital Images RGB Colors The RGB Explorer Digital Images in C++Loading an Image More on Loading an Image Saving an Image Changing the Format

9. Pointers, Arrays & Algorithms

A-Image Filters

Digital Filters Address Arithmetic Iterator Loops The Darken Filter Dealing with Channels State Filters Pointers & Structures Using reinterpret_cast

B-Introducing Arrays

Introducing Arrays Array vs. vector Defining Arrays Array Initialization The Allocated Size Array Selection Characteristics of Arrays

C-Pointers, Arrays & Functions

Pointers & Arrays Pointer Arithmetic & Arrays Dereferencing Arrays Arrays & Functions Decaying Arrays Arrays & Const

D-Arrays & Loops

Arrays and Loops Counter-Controlled Loops Sentinel Loops Iterator Loops A C++ Idiom

E-Arrays & Algorithms

Arrays and Algorithms Counting Algorithms Cumulative Algorithms Extreme Values Returning a Pointer Returning an Index The Fencepost Algorithm A Reverse Fencepost

10. C-Strings, Partially-Filled & 2D Arrays

A-Searching Algorithms

Searching Algorithms The Starter Code The find() Function Linear Search Linear Search Efficiency Improving Linear Search Binary Search Implementing Binary Search

B-Partially-Filled Arrays

An Array Example Appending Elements Traversing the Array Inserting Elements Applying the Algorithm Removing Elements Removing Multiple Elements

C-2D Arrays

2D Arrays Row Major Order 2D Array Initialization 2D Arrays & Functions

D-C-Style Strings

C-Style Strings C-String Basics Array-based C-Strings Pointer-based C-Strings C++ Strings vs. C-Strings C-String Assignment The strncpy Function The strcat Functions Comparing C-Strings

E-Writing C-String Functions

The strlen Function The strcpy Function The strcmp Function Writing Your Own Functions Find First Find Last Find First of Any Finding Substrings

11. Dynamic Memory & Smart Pointers

A-The Command Line

The Shell The Command Line Command-Line Arguments Using Command-Line Arguments Traversing the Arguments Converting Arguments

B-Dynamic Memory

Introducing the Heap Stack vs. Heap The new Operator Dyanmic Arrays Dynamic Objects Freeing Memory

C-Smart Pointers

Memory Management Memory Leaks Dangling Pointers Double Deletes Smart Pointers Shared Pointers Unique Pointers Smart Pointers & Functions Unique Pointers and Containers Unique Pointers and Dynamic Arrays

D-The Problem with Structures

The Iron Age User-Defined Types Object-Based Programming Time as a Structure Type Invariants A Scenario The Problem

E-Member Functions

Information Hiding The Public Interface Member Functions Proving the Interface The Implementation File Implementing Member Functions

12. Object Based Programming with Classes

A-Objects & Classes

Introducing OOP What are Objects State and Behavior What are Classes What is Encapsulation Real World Encapsulation

B-Encapsulation

The Wall of Abstraction Class Definition Syntax Public and Private The Implicit Parameter The Pointer this The sum Member Function

C-Mutators & Constructors

Setters Getter & Setter Patterns Constructors Member Initialization Working Constructor Assignment vs. Initialization The Initializer List

D-More on Classes

The Working Constructor Conversion Constructors Implicit vs. Explicit Assign, Copy & Destroy Static Data Members Static Member Functions static const Data Members

E-Inheritance

Classification Inheritance Person <- Student The UML Diagram Inherited Members Private Base-class Members

13. Inheritance & Polymorphism

A-Derived Constructors

Base-class Constructors Derived-class Constructors Constructor Chaining Default Constructors Calling the Base Constructor Protected Members

B-Overriding Functions

Virtual Member Functions Implementing toString()Overriding toString()Implementing Student::toString()Combining toString()The override Keyword The Stream Class Hierarchy Stream Substitutability Substitution vs. Conversion

C-Polymorphism

Class Relationships Polymorphic Inheritance Static Polymorphism A Perplexing Problem The Slicing Problem References & Pointers Polymorphic Functions Polymorphic Lists Pointers to the Rescue?Maybe Smart Pointers

D-Class Relationships

Early & Late Binding How Late Binding Works Multiple Inheritance Contraction Private Inheritance Composition

E-Specification Inheritance

Specification Inheritance Abstract Classes Creating an Abstract Class Using an Abstract Class A Triangle Example Redefining Functions Final Classes