CSC-234 Module Learning Objectives (MLOs)
To describe
objects and classes, and to use classes to model objects (§9.2).
To use UML
graphical notations to describe classes and objects (§9.2).
To demonstrate
defining classes and creating objects (§9.3).
To create objects
using constructors (§9.4).
To access data fields and invoke
functions using the object member access operator (.) (§9.5).
To separate a
class definition from a class implementation (§9.6).
To prevent
multiple inclusions of header files using the #ifndef
inclusion guard directive (§9.7).
To know what
inline functions in a class are (§9.8).
To declare private data fields with
appropriate get and setter functions for data field encapsulation and make
classes easy to maintain (§9.9).
To understand the
scope of data fields (§9.10).
To apply class abstraction to develop software (§9.11).
To process strings using the string
class (§10.2).
To develop
functions with object arguments (§10.3).
To store and
process objects in arrays (§10.4).
To distinguish
between instance and static variables and functions (§10.5).
To define
constant functions to prevent data fields from being modified accidentally
(§10.6).
To explore the
differences between the procedural paradigm and object-oriented paradigm
(§10.7).
To design a class
for body mass index (§10.7).
To discover the
relationships between classes (§10.8).
To design a class
for a stack (§10.9).
To initialize objects using
constructor initializer lists (§10.10).
To design classes that follow the class-design guidelines (§10.11).
To describe what
a pointer is (§11.1).
To learn how to
declare a pointer and assign a memory address to it (§11.2).
To access values
via pointers (§11.2).
To define
synonymous types using the typedef keyword (§11.3).
To declare
constant pointers and constant data (§11.4).
To explore the
relationship between arrays and pointers (§11.5).
To access array
elements using pointers (§11.6).
To pass pointer
arguments to a function (§11.7).
To learn how to
return a pointer from a function (§11.8).
To use the new
operator to create dynamic arrays (§11.9).
To create objects
dynamically and access objects via pointers (§11.10).
To reference the calling object
using the this pointer (§11.11).
To implement the
destructor for performing customized operations (§11.12).
To design a class
for students registering courses (§11.13).
To create an
object using the copy constructor that copies data from another object of the
same type (§11.14).
To customize the copy constructor for performing a deep copy (§11.15).
To use ofstream for output (§13.2.1) and ifstream
for input (§13.2.2).
To test whether a
file exists (§13.2.3).
To test the end
of a file (§13.2.4).
To let the user
enter a filename (§13.2.5).
To write data in
a desired format (§13.3).
To read and write data using the getline, get, and put functions (§13.4).
To use an fstream object to read and write data (§13.5).
To open a file
with specified modes (§13.5).
To use the eof(), fail(), bad(), and
good() functions to test stream states (§13.6).
To understand the
difference between text I/O and binary I/O (§13.7).
To write binary
data using the write function (§13.7.1).
To read binary
data using the read function (§13.7.2).
To cast primitive
type values and objects to byte arrays using the reinterpret_cast
operator (§13.7).
To read/write
arrays and objects (§§13.7.3–13.7.4).
To use the seekp and seekg functions to move
the file pointers for random file access (§13.8).
To open a file for both input and output to update files (§13.9).
To know operator
overloading and its benefits (§14.2).
To define the
Rational class for creating rational numbers (§14.2).
To discover how
an operator can be overloaded in C++ using a function (§14.3).
To overload the relational
operators (<, <=, ==, !=, >=, >) and arithmetic
operators (+, −, *, /) (§14.3).
To overload the
subscript operator [] (§14.4).
To overload the augmented
assignment operators +=, −=, *=, and /= (§14.5).
To overload the unary operators +
and − (§14.6).
To overload the
prefix and postfix ++ and −− operators (§14.7).
To enable friend
functions and friend classes to access a class’s private members (§14.8).
To overload the
stream insertion and extraction operators << and >> as friend nonmember
functions (§14.9).
To define
operator functions to perform object conversions to a primitive type (§14.10.1).
To define
appropriate constructors to perform conversions from a numeric value to an
object type (§14.10.2).
To define
nonmember functions to enable implicit type conversions (§14.11).
To define a new
Rational class with overloaded operators (§14.12).
To overload the = operator to perform a deep copy (§14.13).
To define a
derived class from a base class through inheritance (§15.2).
To enable generic
programming by passing objects of a derived type to a parameter of a base class
type (§15.3).
To know how to
invoke the base class’s constructors with arguments (§15.4.1).
To understand
constructor and destructor chaining (§15.4.2).
To redefine
functions in the derived class (§15.5).
To distinguish
between redefining and overloading functions (§15.5).
To define generic
functions using polymorphism (§15.6).
To enable dynamic
binding using virtual functions (§15.7).
To distinguish
between redefining and overriding functions (§15.7).
To distinguish
between static matching and dynamic binding (§15.7).
To override
virtual functions using the override keyword and use the final keyword to
prevent further overriding (§15.8).
To access
protected members of a base class from derived classes (§15.9).
To define
abstract classes with pure virtual functions (§15.10).
To cast an object of a base class type to a derived type using the static_cast and dynamic_cast operators and know the differences between the two operators (§15.11).
To get an
overview of exceptions and exception handling (§16.2).
To know how to
throw an exception and how to catch it and explore the advantages of using
exception handling (§16.2).
To create
exceptions using C++ standard exceptions classes (§16.3).
To define custom
exception classes (§16.4).
To catch multiple
exceptions (§16.5).
To explain how an
exception is propagated (§16.6).
To rethrow exceptions in a catch block (§16.7).
To use exception handling appropriately (§16.8).