Final Topic Review

The final exam is comprehensive. This outline focuses on contents after midterm II and should be used together with the past midterm reviews.

Materials to prepare (sorted by the order of importance)

1. Practice exam

2. Past midterm exams

3. Past projects (know what you did wrong)

4. This outline and outlines for past exams

5. Course notes website

6. Zybook content and activities

Hint and tips for preparation

• All contents covered in the semester will be tested

• Self-test using this document to see what concepts are challenging to you.

• Course notes document is the main resource for tips, pitfalls. High priority in midterm preparation.

• The past midterm exams are important materials to prepare.

• Re-do all participation activities and challenge activities in zyBook

• Practice your ability to finish the patterns listed here from scratch without editor or IDE

Memory management (class)

1. Rule of three:

   • The big three

   • Implicitly-declared methods

   • How they are triggered, and when they are needed

   • Only needed when dynamic data exist

   • Destructor to avoid memory leak

   • Copy constructor and copy assignment operator overloading to avoid shallow copy

   • Syntax of the three

     • const reference parameters (except destructor)

     • reference returned type (copy assignment operator)

   • access the private member of another object of the same class directly

   • Must know how to write a simple class with all three!

2. Deep and shallow copy concepts

   • The dynamically allocated instance variables of an object are stored as two parts: the pointer itself and the actual content they referred to (in the heap memory region).

   • If you do not provide the big three, default versions will be created by the compiler. The default big three will always perform shallow copy.

   • Shallow copy: only the pointers are duplicated. The actual content stays same. Thus, pointers from both objects refer to the same content.

   • Deep copy: New memory is allocated first and the dynamic contents are duplicated.

Input/output

• stream - sequence of data transmitted in the input or output process

Standard I/O

• iostream header

• standard input

  • istream class

  • cin is a provided istream typed object(variable)

• standard output

  • ostream class

  • cout is a provided ostream typed object(variable)

File I/O

• fstream header

• ifstream class

• ofstream class

• steps to use files

  • open file (open method or constructor)

  • check open status (.fail() or .is_open())

  • input / output

    • loop

    • check eof

    • know the patterns

  • close file

String I/O

• sstream header (not stringstream!)

• Input string stream - istreamstream class

  Used to parse textual content and extract data.

  • constructor to load a string

  • str() method to load a string

• Output string stream - ostreamstream class

  Used to generate text with formatted data in it.

  • str() method to give a string

Stream I/O Operations

• iomanip header

• Insertion

  • output manipulator

    • fixed

    • setprecision(n)

    • setw(n) Not sticky!

    • setfill(c)

    • endl

  • can be chained

  • pattern: tabula display

• Extraction

  • chained

  • auto type conversion

  • use as bool value

• getline(inputStream, line)

  • read a text till the delimiter from a istream object (include istringstream and ifstream)

  • use stoi, stod etc. to convert to numeric values

  • may read in empty line after use of >> operator Must know how to handle that!

• Error handling

  • do not check too often

  • check right after the read

  • call .clear() to reset the error bits

• pitfalls

  • .fail() should be check after every essential extraction, and getline operations.

  • getline after extraction without protection.

  • expect getline to read non-string-typed values

String manipulation

• string member functions

  • .find()

    • find a pattern in a text

    • return string::npos if pattern not found

    • second optional parameter to specify the start index to search from

  • .substr(startIdx, length) - extract substring

  • .length()/.size()

• Standalone functions

  • stoi()

  • stod()

• operators

  • enabled by operator overloading in the string class

  • addition + for concatenation

  • =, ==, !=

  • avoid <, <=, >, >=

Vector

• models a list/sequence with variable length

• class type

• flexible length

• Implemented as a dynamic array

• Constructors

  • initial size

  • repetition

  • copy

  • initializer list

• member functions (methods)

  • at(i) - access element with index, never use [] syntax

  • size() - get size, not length()!

  • empty() - check if the vector is empty

  • clear() - clears the content

  • resize() - change the size

  • back() - get the last value

  • push_back(element) - add an element to the end, size will increase by one

  • pop_back(element) - remove an element at the end, does not return that value, size will decrease by one

• operators

  • = assignment

  • ==, !=

Patterns

Patterns are something you should be able to reproduce in an exam environment.

• Write complete classes (hpp/cpp file pair) and a driver with provided specifications (class name, method description, instance variable, etc.)

• Write complete classes and a driver with the big three and dynamic data

• Write complete classes to operate on files

• Write functions of array related algorithms on vectors

• Write programs to correctly read/write files with error handling

• Read data from a file till the end

• Write functions/methods to parse text using istringstream

• Write functions/methods to parse text using string methods

• Write formatted (tabular) output to screen

• Write functions/methods to generate formatted text using ostringstream and formatting manipulators

• Use extraction and getline together