Midterm 1 Topic Review

How to prepare

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

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

  • Review all participation activities and challenge activities in zyBook

  • Practice your ability to finish the coding patterns listed here from scratch without the assistance from the editor/ IDE

Topics

Environment

  • Command-line interface (CLI)

    • add prefix ./ to run an executable in the current directory

  • keyboard input (will wait for enter key)

  • screen output

  • Basic Linux bash command: ls, mkdir, cd, rm, mv, vi/vim, man, ssh

  • Compilation command: g++

    • fundamental flags -o -std -Wall

    • step-wise compilation

  • Building: make

    • Understand hard-coded rules (makefile variables not required in exam)

General C++ concepts

  • name/identifier rule

    • digit, letter, underscore

    • digit cannot be first character

    • avoid conflict with keyword

  • Three ype of errors

  • Comments

    • line //

    • block /* */

    • documentation - comments above declarations to document classes or functions

  • Debugging

    • Manually debugging - run code, provide different input and check output

    • tracing - add cout << statements to your code to show values of variables

  • Testing

    • Write additional code to feed various input (parameters) to functions/methods and check whether the outputs are as expected

    • assert macro (similar to function)

      • cassert header

Variable & expressions

  • integer division

    • truncate, loose precision

  • modulo

    • int only!

  • type cast/conversion

    • explicit/type cast

      • static_cast<NewType>(variable)

      • avoid C style type conversion like (int) variable (points off in exam)

    • implicit/conversion

      • assignment to a variable of a different type. E.g. int a = 4.5;

      • mixed operation like 3 + 5.0 (a type of smaller range automatically converted to a type of larger range)

      • parameter passing (same as initialization/assignment)

  • Operators

    • arithmetic

    • relationship

    • logical

    • bitwise know they exist, should not confuse with logical ops

    • precedence rule

  • complex expression evaluation

  • textual literals

    • char ‘a’

    • string “string”

    • escape sequence

      • \n

      • \t

      • \\

  • Array basics

    • declaration syntax with []

    • size must me a compilation-time constant (literal or const variable)

    • initialization syntax (size infer)

    • element access with the [] operator

  • Reference basics

    • declaration with mandatory initialization

    • an alias of a variable

    • mostly used in parameter passing

Control flows

  • Three types

  • Branch

    • if-else

    • switch

      • break

  • Loop

    • while

    • do-while (cannot handle all scenarios)

    • for

    • break

    • continue

  • examples

    • statements with child blocks if, else, while, for

      • no statement like if (expr1); (meaningless but compilable)

      • one statement like if (expr1) statement;

      • code block like if (expr1) {statement; ...}

    • interconversion

      • while; do-while; for

      • if-else; switch

Functions

  • declaration/prototype syntax

    • public declarations should be in header files if they exist

    • may omit parameter name

  • definitions/implementation syntax

    • in cpp files if they exist

    • must have parameter name

    • may have default value

  • function call syntax (no parameter types)

  • Default value for parameters

    • from right to left

    • should only appear once, either in declaration or in definition

    • strongly recommended to put in declaration only

  • parameter passing

    • pass-by-value (default way)

    • pass-by-ref

      • use & after the type in the formal parameter list

      • must use a single variable as the actual parameter in function call

      • formal parameter will serve as an alias of the actual parameter

      • reason 1: avoid copying large obj (may use const to avoid modification)

      • reason 2: modify the actual parameters passed to it

  • function overloading

    • same name but different parameter types, count or order

    • function call matching

      • exact match

      • match with compatible types

    • things that do not count

      • differ only in return type

      • differ only in names of formal parameters

  • scope

    • block scope (for loop example)

    • shadowing example

Class

  • concepts

    • class is a type

    • object/instance is a variable of a class type

    • members

      • member variables / instance variables

      • member functions / methods

    • access modifier

      • section based (different from Java)

      • public

      • private (default)

    • static members (know they exist, details not required)

  • syntax

    • class declaration

      • public declarations should be in header files if they exist

      • may contain implementation (in-line function)

      • may omit formal parameter names (not recommended)

      • trailing ; after }

    • member function definition (out-of-line)

      • should be in cpp files

      • must use :: operator to specify the ownership of the functions

      • must have formal parameter names

    • member variable access and member function call

      • use variableName.functionName()

    • this pointer

      • use -> syntax to access members

      • this-> can be omitted when name does not conflict

    • const function (not const variables or const parameters)

      • const keyword after the parenthesis in both declaration and definition

      • prevent a function from modifying any member variables

      • getters for example

  • member function overloading

  • special member functions

    • constructor

      • may overload

      • default constructor

      • parameterized constructor

      • no return type

      • same name as the class

    • destructor

      • only one

      • no parameter

      • no return type

      • add ~ before the name of the class

    • getter/accesser

    • setter/mutator

      • this-> syntax when name conflicts

Modular Development

  • Module:

    • a pair of header/implementation files per class (or a group of classes)

    • a pair of header/implementation files per group of functions

  • Runner/driver - usually main.cpp file, with a main function

  • .hpp header file in a module

    • header guard (#ifndef, #define, #endif)

    • public declarations of class(es) or function(s)

    • include only libraries required by declarations

  • .cpp file in a module

    • include libraries required by the implementation (function/method definitions)

    • declarations used in the current file only

    • function/method definitions

  • .cpp file as a driver/runner

    • main function

  • Never include cpp files!!!

  • g++

    • handles all three steps of the compilation process

      1. preprossing

      2. compilation

      3. linking

    • add -c flag to preprocess and compile only; generate object files (usually named as .o files)

    • use -o flag to specify the name of the output file (either executable or object file)

    • use -Wall flag to display all warnings

    • use -std=c++14 to follow the C++ 2014 standard

    • never provide .hpp file to g++ commands!

  • make

    • know the simple g++ commands

    • use of variables in makefile will not be tested!

    • automate the building (preprossing, compilation, linking) process

    • makefile

      • Must use tab for indentation

      • syntax

        <target> : <dependencies/prerequisites>
        <recipe/commands>

      • example

        main : main.o lib1.o
    g++ -o main main.o lib1.o

Top-down design

  • Will not be directly tested in exam but you will do a lot better in the coding questions if you know how to apply the rule!

  • divide problem into sub-tasks

  • keep dividing sub-tasks to sub-sub-tasks as necessary

  • work from top level to bottom level

  • finish bigger picture design before digging into sub-tasks

  • work iteratively - keep improving the design during development

Object oriented design

  • Will only test very simple concepts.

  • Identify/diagnose ownerships between classes and members

  • identify objects and classes (concepts, nouns)

  • identify states of objects, a.k.a. member variables (concepts, attributes, nouns)

  • identify behavior of objects, a.k.a. member functions (relationships, verbs)

Frequently Tested Contents

  • Finish coding on paper or in a plain text editor like notepad

  • Write a full program project in a single cpp file

  • Write full or part of a modular project

    • header/cpp pairs and driver/runner cpp file

    • how includes works

    • header guards

    • how to make them work together

    • how to compile using g++ commands and simple makefile

    • refer to Lab 2 and Project 1

  • Write a full function

    • based on problem description

    • based on function usages

    • Pass-by-ref functions, e.g. swap in code example

  • Write a full class

    • class declaration

    • method definitions

    • both single file or multi-file

    • based on class usages

  • Input with validation pattern

  • Complex expression evaluation - stepwise

  • Output of a tricky loop/branch

    • stepwise

  • Function overloading and call matching

  • Pitfalls. Find them in the notes. Some are listed here.

    • modulo on non-int values

    • initialization only syntax

    • & vs &&, | vs ||

    • switch w/o break

    • switch on double value

    • optional {} in if/while/for

    • empty if/while/for like if (expr);

    • wrong syntax of array like int [] arr

    • mismatched function call

    • out of scope use of variables

    • off-by-one in loops (check border conditions)

    • infinite loops (missed termination condition)

    • while loops that checked condition at a wrong place. always use while (true) loop to avoid

    • ; after the } in a class declaration

    • constructor only syntax

      • initializer list

      • no return type

    • forget MyClass:: prefix in method definitions

    • use public/private as method prefix rather than sections

Examples

  • complex expressions

    • step-wise evaluation

    • precedence rule

    • implicit conversion

    • explicit type cast

    ((3 / 4 + (9 + 3) ) / 3.0 - 3) / ( 1 + (2 * 3))
= ((3 / 4 + 12) / 3.0 - 3) / ( 1 + 6)
= ((0 + 12) / 3.0 - 3) / 7
= (12 / 3.0 - 3) / 7
= (4.0 - 3) / 7
= 1.0 / 7
= 0.14...

((17 / 2 + 19 % 3 + 6) >= (5 + 2 * 4)) && !(((4 * 5) + 1) / 2 == (7 / 3 + 2 * 5 - 2) || !(4 >= 3))
= ((8 + 1 + 6) >= (5 + 8)) && !((20 + 1) / 2 == (2 + 10 - 2) || !(4 >= 3))
= (15 >= 13) && !(21 / 2 == 10) || !(4 >= 3)
= (15 >= 13) && !(10== 10) || !(4 >= 3)
= true && !(true || !true)
= false