CSCI 123 – Exam 3 – Final Exam Study Guide

Exam Date: Wednesday, December 6th, 2023, at 4:15pm

Permitted Materials:

• Pen(s), pencil(s), eraser(s)

• One (1) handwritten 3-inch x 5-inch index card. Both sides of this index card may be used for your hand-
written notes, (i.e. written in your handwriting, not typed). If you do not comply with these instruc-
tions, you will not be permitted to use your index card during the exam.
• A scientific calculator. No graphing calculators, phones, or smart devices are permitted.

Topics

• Input/Output via iostream - (Chapter 1-2)

◦ cout and insertion operator <<

◦ cin and extraction operator >>
◦ Insert new lines via endl or "\n"
◦ Print complex output via multiple <<
◦ std namespace

• Program Structure – (Chapter 1-2)

◦ The main() function

◦ Inclusion of libraries
◦ The placement of function declarations and definitions in a program file

• Variable Declaration and Assignment – (Chapter 2)

◦ Define what a variable actually is

◦ Declaration statements
▪ initialization of variables within a declaration statement

◦ Assignment statements

◦ Values assignable to variables

▪ type-specific literals
▪ other variable’s values
▪ results of expressions and function calls (see Chapter 4)

◦ The const modifier

• Data Types – (Chapter 2)

◦ Values and ranges

◦ Implicit vs. explicit conversions

▪ know what triggers an implicit conversion
▪ static_cast()
 Page 2 of 6

• Expressions – (Chapter 2-3)

◦ Arithmetic expressions
◦ Boolean expressions
◦ Precedence of arithmetic and boolean operators
◦ Evaluation and use of expressions in statements
◦ Use of function calls in expressions (see Chapter 4)

• Control Structures – (Chapter 2-3)

◦ if
◦ else-if
▪ add else-if to select from multiple options

◦ switch
▪ alternative to if/else-if
▪ use of break and default keywords

◦ while vs. do-while

◦ for
▪ initialization of dedicated loop variable
▪ iterate an arbitrary number of times
▪ different ways to iterate through loop (i++, i--, i = i+2)
▪ nested for loops

◦ The break keyword in loops

◦ Know when you would use while loop vs. for loop

• Calling Functions Defined in Libraries – (Chapter 4)

◦ <cmath>
▪ pow()
▪ sqrt()
▪ ceil()
▪ floor()

◦ <cstdlib>
▪ srand()
▪ rand()
▪ understand the need for a unique seed per program execution

◦ <ctime>
▪ time()

• Scope – (Chapter 4)

◦ Block scope and locality

◦ Scope within functions
◦ Local variables
◦ Scope within nested blocks
 Page 3 of 6

• Defining Functions – (Chapters 4-5)

◦ Function definition vs. function declaration vs. function call

◦ Flow of program control to function body
◦ Arguments vs. parameters
◦ Selecting a return type that aligns with a function's purpose

◦ Values that can be returned from a function:

▪ Literals
▪ Variables
▪ Expressions
▪ Values returned from other functions

◦ Call-by-value parameters
▪ A copy of an argument's value passed in during a function call
▪ Allows literals as arguments

◦ Call-by-reference parameters
▪ A reference to the memory address of an argument passed in during a function call
▪ In other words, a function will directly manipulate an argument's value
▪ Forbids literals as arguments

◦ Function overloading
▪ Know how to write an overloaded function
▪ Minimum requirements for overloading

• Input/Output via <fstream>/<iostream> libraries – (Chapter 6)

◦ Create <ifstream>/<ofstream> stream objects via constructor functions

• calling the default constructor function
• calling the one-argument constructor function – what does this argument initialize?

◦ Insertion operator (<<)

◦ Extraction operator (>>)

▪ how to continuously read until the end of the file
▪ potential issues related to input

◦ Stream object member functions

▪ .open()
▪ .close()

◦ .getline() - non-member function

◦ Stream objects as function parameters

▪ call-by-reference required
▪ ofstream/ifstream vs. ostream/istream

◦ Character functions – require <cctype> library

▪ toupper()
▪ tolower()
▪ isalpha()
▪ isdigit()
 Page 4 of 6

• One-dimensional Arrays – (Chapter 7)

◦ Declaration
◦ Initialization
◦ Upper and lower bounds
◦ Access and modification of individual elements via indexing
◦ Arrays as function parameters – pass array and size
◦ Limitations of compile-time arrays

• Strings – (Chapter 8)

◦ requires <string> library

▪ .length()
▪ .find()
▪ .substr()

◦ String concatenation with addition operator (+)

◦ String variables as function parameters, how to return a string from a function

• Vectors – (Chapter 8)

◦ Advantages of vectors compared to arrays

◦ How to construct a vector object

▪ specifying the data type of vector
▪ difference between calling the default constructor vs. passing in an argument

◦ Vectors as function parameters

▪ when to use call-by-value vs. call-by-reference

◦ Member functions:
▪ .size()
▪ .at() - compare with traditional array indexing
▪ .push_back()
▪ .pop_back()

• Pointers – (Chapter 9)

◦ How to declare a pointer variable

▪ what type of value does a pointer store?

◦ How to assign addresses to pointers

▪ the values of other pointers
▪ references to stack-allocated variables
• the reference operator - (&)

▪ arrays
▪ accessing an array through a pointer

◦ How to dereference a pointer via * to access a pointed-to variable - *<pointer identifier>

◦ Use of new keyword to dynamically allocate variables and arrays (using [])
 Page 5 of 6

• Pointers – (Chapter 9) – (continued)

◦ Deletion of dynamically-allocated variables and arrays

▪ delete keyword – no-[] vs. []
▪ dangling pointers
▪ memory leaks

◦ [TO BE DETERMINED]

▪ Pointers to class objects (i.e. object pointers)

• use of the arrow operator ( -> ) - see Chapter 13

• Structures – (Chapter 10)

◦ Adding member variables

◦ Creating a structure variable
◦ Accessing a structure’s members
◦ Modifying a structure’s members

• Classes – (Chapter 10)

◦ Defining member functions:

▪ inside of the class definition
▪ outside of the class definition
• use of the scope resolution operator (::)
• ability to use private members in definition

▪ calling member functions

▪ what does the term “calling object” mean with respect to a called member function?

◦ Constructor functions
▪ how to include a default constructor in your class definition
▪ initialization section syntax (p. 584) - <member data>(<constructor parameter>)

◦ Access modifiers
▪ public vs. private
▪ when you can and cannot use a private member
▪ encapsulation – Savitch 566

◦ Accessor/”getter” and mutator/”setter” member functions

▪ used to access or modify private member data
▪ by convention, use the words get or set in function names
▪ return types of getters: think about what type of value you’re trying to get

• Classes (advanced) – (Chapter 11)

◦ Dynamic arrays in classes

▪ initializing via a constructor function

◦ The copy constructor function – Savitch 678-679

▪ Know when it is used
▪ shallow copy vs. deep copy
 Page 6 of 6

• Classes (advanced) – (Chapter 11) - (continued)

◦ Destructor function
◦ Friend functions
◦ Constant parameters within member functions
◦ Constant member functions
◦ Binary Operator Overloading (+, -, <<, >>)

• Inheritance – (Chapter 15)

◦ How to derive a class from a base class via public inheritance

▪ Inheriting member variables and functions

• As a derived class, do I have access to my base class’ private members?

▪ Adding member variables and functions

▪ Redefining member functions
▪ Calling a base version of a redefined function
▪ Calling a base constructor in a derived constructor’s definition
▪ The use of a base class’ destructor in a derived destructor’s definition